Entities and Repositories | Database Integration Tutorial

This section dives into how Spring Boot interacts with databases using JPA (Java Persistence API), Entities, and Repositories. We'll focus on simplifying database access and management.

1. Understanding JPA and ORM

JPA (Java Persistence API): A specification for managing relational data in Java. It defines how to map Java objects to database tables.
ORM (Object-Relational Mapping): The technique of converting data between incompatible systems using an object-oriented programming language and a relational database. JPA implementations (like Hibernate, EclipseLink) handle this conversion.
Benefits of using JPA/ORM:
- Reduced Boilerplate Code: Less SQL writing and manual data mapping.
- Portability: Switching database systems becomes easier (with some adjustments).
- Object-Oriented Approach: Work with Java objects instead of raw database records.
- Data Integrity: JPA providers often handle data validation and consistency.

2. Defining Entities

Entities represent the tables in your database. They are Java classes annotated with JPA annotations.

Example: User Entity

import javax.persistence.*;

@Entity // Marks this class as a JPA entity
@Table(name = "users") // Specifies the database table name (optional, defaults to class name)
public class User {

    @Id // Marks this field as the primary key
    @GeneratedValue(strategy = GenerationType.IDENTITY) // Auto-incrementing primary key
    private Long id;

    @Column(name = "username") // Specifies the column name (optional, defaults to field name)
    private String username;

    @Column(name = "email")
    private String email;

    // Getters and Setters (omitted for brevity)
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getUsername() { return username; }
    public void setUsername(String username) { this.username = username; }
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
}

Key Annotations:

@Entity: Indicates that the class is a JPA entity.
@Table: Specifies the database table associated with the entity.
@Id: Marks a field as the primary key.
@GeneratedValue: Configures how the primary key is generated. GenerationType.IDENTITY uses the database's auto-increment feature. Other options include SEQUENCE, TABLE, and AUTO.
@Column: Maps a field to a specific database column. Allows customization of column name, length, and other properties. If omitted, the field name is used as the column name.

3. Creating Repositories

Repositories provide an abstraction layer for database access. Spring Data JPA simplifies repository creation significantly.

Example: UserRepository Interface

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

@Repository // Marks this class as a repository (optional, Spring usually detects it)
public interface UserRepository extends JpaRepository<User, Long> {

    // You can add custom query methods here (see section 5)
    User findByUsername(String username);
}

Explanation:

JpaRepository<User, Long>: This is a Spring Data JPA interface that extends the basic repository functionality.
- User: The entity type this repository manages.
- Long: The type of the primary key.
Spring Data JPA automatically generates implementations for common database operations (CRUD - Create, Read, Update, Delete) based on the interface methods.
@Repository: Marks the interface as a repository component. While often optional, it's good practice to include it for clarity.

4. Connecting to the Database

Configure your database connection in application.properties or application.yml.

Example (application.properties):

spring.datasource.url=jdbc:mysql://localhost:3306/mydatabase
spring.datasource.username=myuser
spring.datasource.password=mypassword
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.jpa.hibernate.ddl-auto=create-update # Automatically create/update schema
spring.jpa.show-sql=true # Show generated SQL queries in the console

Explanation:

spring.datasource.url: The JDBC connection URL.
spring.datasource.username: Database username.
spring.datasource.password: Database password.
spring.datasource.driver-class-name: The JDBC driver class name.
spring.jpa.hibernate.ddl-auto: Controls how the database schema is managed.
- create: Creates the schema if it doesn't exist (drops existing data!).
- create-drop: Creates the schema and drops it when the application stops.
- update: Updates the schema based on entity changes (preserves data). Recommended for development.
- none: No schema management.
spring.jpa.show-sql: Enables logging of SQL queries. Useful for debugging.

5. Using Repositories in Your Service Layer

Inject the repository into your service layer and use its methods to interact with the database.

Example: UserService

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    public User createUser(String username, String email) {
        User user = new User();
        user.setUsername(username);
        user.setEmail(email);
        return userRepository.save(user); // Save the user to the database
    }

    public User findUserByUsername(String username) {
        return userRepository.findByUsername(username); // Use the custom query method
    }
}

Explanation:

@Autowired: Injects the UserRepository instance into the UserService.
userRepository.save(user): Saves the user entity to the database. Handles INSERT and UPDATE operations.
userRepository.findByUsername(username): Calls the custom query method defined in the UserRepository interface.

6. Custom Query Methods

Spring Data JPA allows you to define custom query methods in your repositories.

Naming Conventions:

findBy<Property Name>: Finds an entity by a specific property value. (e.g., findByUsername)
findBy<Property Name>(<Value>): Finds an entity with a specific property value. (e.g., findByEmail(String email))
findBy<Property Name>Containing(<Value>): Finds entities where the property contains the specified value. (e.g., findByUsernameContaining(String username))
findBy<Property Name>OrderBy<Property Name>(<Sort Order>): Finds entities ordered by a specific property. (e.g., findByLastNameOrderByFirstName(Sort.Direction.ASC))

Using @Query Annotation:

For more complex queries, use the @Query annotation.

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

@Repository
public interface UserRepository extends JpaRepository<User, Long> {

    @Query("SELECT u FROM User u WHERE u.username = ?1")
    User findUserByUsernameQuery(String username);
}

Explanation:

@Query("SELECT u FROM User u WHERE u.username = ?1"): Defines a custom JPQL (Java Persistence Query Language) query.
?1: A placeholder for the first parameter (in this case, the username).

This provides a solid foundation for database integration in your Spring Boot applications. Remember to adapt the code examples to your specific database schema and requirements.