Definindo entidades e repositórios

In this lesson, we'll learn how to connect your Java application to a database using Spring Boot. This is called data persistence, meaning your data lives on even after your app stops.

We'll focus on two core concepts:

• Entities: Your Java objects that map to database tables.
• Repositories: Interfaces that provide easy ways to interact with your entities and the database.

A JPA Entity is a plain Java class that represents a table in your relational database. Each instance of this class corresponds to a row in that table.

The Java Persistence API (JPA) is a standard for managing relational data in Java applications. Spring Data JPA builds on this to simplify database interactions even further.

To mark a Java class as a JPA Entity, you use the @Entity annotation. You also need to define a primary key using @Id.

Let's create a simple Product entity:

Manually assigning IDs can be tedious and prone to errors. Databases can automatically generate unique IDs for you!

Use the @GeneratedValue annotation along with a strategy. GenerationType.IDENTITY is common for databases that auto-increment (like MySQL, H2).

By default, JPA maps fields to columns with the same name. You can customize this using the @Column annotation.

It lets you specify the column name, whether it's nullable, its length, and more:

Now that we have an entity, how do we save it to the database or retrieve it? That's where Spring Data Repositories come in!

A repository is an interface that provides powerful, pre-built methods for common database operations (like Create, Read, Update, Delete - CRUD). You don't write SQL; Spring Data JPA generates it for you.

To create a repository for your entity, you simply define an interface that extends Spring Data JPA's JpaRepository.

The JpaRepository takes two type parameters: the Entity type and the type of its Primary Key.

Here's how you'd define a repository for our Product entity:

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

// Assuming 'Product' entity is defined in the same package or imported
@Repository
public interface ProductRepository extends JpaRepository<Product, Long> {
    // Spring Data JPA automatically provides CRUD methods here!
    // You can add custom query methods if needed, e.g.,
    // List<Product> findByName(String name);
}

Note: The @Repository annotation is optional but good practice for clarity.

By extending JpaRepository, your ProductRepository automatically inherits many powerful methods. Here are a few:

• save(entity): Saves a given entity (inserts if new, updates if exists).
• findById(id): Retrieves an entity by its ID, returning an Optional.
• findAll(): Returns all instances of the entity type.
• delete(entity) or deleteById(id): Removes an entity.

This means you get full CRUD functionality without writing a single line of implementation code!

In a real Spring Boot application, you would inject your repository into a service or controller using @Autowired and then call its methods.

While we can't run a full Spring Boot app with a database here, this snippet shows the conceptual usage within a typical Spring Boot component:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;

// Assuming Product and ProductRepository are defined

@Service
public class ProductService {

    private final ProductRepository productRepository;

    @Autowired
    public ProductService(ProductRepository productRepository) {
        this.productRepository = productRepository;
    }

    public Product createProduct(String name, double price) {
        Product newProduct = new Product(name, price);
        return productRepository.save(newProduct);
    }

    public List<Product> getAllProducts() {
        return productRepository.findAll();
    }

    public Product getProductById(Long id) {
        return productRepository.findById(id).orElse(null);
    }
}

This ProductService would then be used by other parts of your application.

Great job! You've learned the foundations of data persistence with Spring Data JPA:

• Entities are Java classes annotated with @Entity that map to database tables.
• @Id marks the primary key, and @GeneratedValue lets the database handle ID generation.
• @Column allows you to customize field-to-column mappings.
• Repositories are interfaces that extend JpaRepository<Entity, ID>, providing powerful, ready-to-use CRUD methods without writing SQL.

Next, you'll dive deeper into performing various CRUD operations!