Entity and Configuration

📦 Data Persistence Basics: Your Database Filing Cabinet

Imagine you have a magical filing cabinet that never forgets anything. That’s what Jakarta Persistence does for your Java apps!

🎯 The Big Picture

Think of your computer like a forgetful friend. Every time you turn it off, it forgets everything! But we need our apps to remember things - like your high score, your profile, or your shopping cart.

Jakarta Persistence (JPA) is like giving your Java app a super-organized filing cabinet that:

• 📁 Saves your data safely
• 🔍 Finds it quickly when needed
• 🔄 Keeps everything organized

🗺️ What We’ll Learn

graph TD
    A["Jakarta Persistence Overview"] --> B["Persistence XML"]
    B --> C["Persistence Unit"]
    C --> D["Entity Classes"]
    D --> E["Entity Lifecycle"]
    E --> F["Entity States"]

    style A fill:#667eea,color:#fff
    style B fill:#764ba2,color:#fff
    style C fill:#f093fb,color:#fff
    style D fill:#f5576c,color:#fff
    style E fill:#4facfe,color:#fff
    style F fill:#00f2fe,color:#fff

1️⃣ Jakarta Persistence Overview

What Is It?

Jakarta Persistence (formerly called JPA) is like a translator between your Java code and your database.

Why Do We Need It?

Without JPA 😫

// So much work!
String sql = "INSERT INTO students " +
    "(name, age) VALUES (?, ?)";
PreparedStatement ps =
    conn.prepareStatement(sql);
ps.setString(1, "Emma");
ps.setInt(2, 10);
ps.executeUpdate();

With JPA 😊

// So simple!
Student emma = new Student();
emma.setName("Emma");
emma.setAge(10);
entityManager.persist(emma);

The Magic Explained

JPA works like a librarian:

1. 📝 You give them a book (your data object)
2. 📚 They know exactly where to put it (the database)
3. 🔍 They can find it instantly when you ask

2️⃣ Persistence XML Configuration

What Is persistence.xml?

Think of persistence.xml as the recipe card for your filing cabinet. It tells JPA:

• 📍 Where is the database?
• 🔑 What’s the password?
• ⚙️ How should things work?

Where Does It Live?

📁 your-project/
  📁 src/main/resources/
    📁 META-INF/
      📄 persistence.xml  ← Here!

Basic Structure

<?xml version="1.0"?>
<persistence
  xmlns="https://jakarta.ee/xml/ns/persistence"
  version="3.0">

  <persistence-unit name="myApp">
    <!-- Settings go here -->
  </persistence-unit>

</persistence>

Essential Settings Explained

Complete Example

<?xml version="1.0"?>
<persistence
  xmlns="https://jakarta.ee/xml/ns/persistence"
  version="3.0">

  <persistence-unit name="schoolDB">
    <!-- The engine that does the work -->
    <provider>
      org.hibernate.jpa.HibernatePersistenceProvider
    </provider>

    <!-- Our data classes -->
    <class>com.school.Student</class>
    <class>com.school.Teacher</class>

    <!-- Database connection -->
    <properties>
      <property name="jakarta.persistence.jdbc.url"
        value="jdbc:h2:./mydb"/>
      <property name="jakarta.persistence.jdbc.user"
        value="admin"/>
      <property name="jakarta.persistence.jdbc.password"
        value="secret123"/>
    </properties>
  </persistence-unit>
</persistence>

3️⃣ Persistence Unit

What Is a Persistence Unit?

A Persistence Unit is like a team that works together:

• 🏢 One database
• 📦 A group of related entities
• ⚙️ Shared settings

Real-World Analogy

Think of a school with different offices:

Why Multiple Units?

Sometimes you need separate filing cabinets:

• 🔒 Different security levels
• 🌍 Different databases
• 📊 Different configurations

Creating an EntityManager

// Step 1: Create the factory
EntityManagerFactory factory =
    Persistence.createEntityManagerFactory(
        "schoolDB"  // matches persistence.xml
    );

// Step 2: Get a manager to do the work
EntityManager em =
    factory.createEntityManager();

// Step 3: Use it!
Student found = em.find(Student.class, 1);

4️⃣ Entity Classes

What Is an Entity?

An Entity is a Java class that represents one row in a database table.

graph LR
    A["Java Object"] -->|"@Entity"| B["Database Row"]

    style A fill:#667eea,color:#fff
    style B fill:#4facfe,color:#fff

The Magic Annotation

Just add @Entity to any class:

@Entity  // ← This is the magic word!
public class Student {

    @Id  // ← Every entity needs an ID
    private Long id;

    private String name;
    private int age;

    // Getters and setters...
}

Essential Annotations

Complete Entity Example

@Entity
@Table(name = "students")  // Table name
public class Student {

    @Id
    @GeneratedValue(strategy = AUTO)
    private Long id;  // Auto-generated!

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

    @Column(nullable = false)
    private int age;  // Can't be empty

    private String email;  // Uses "email" as column

    // Constructor
    public Student() {}

    // Getters and setters...
}

What Gets Created?

students table:
┌────┬───────────┬─────┬─────────────────┐
│ id │ full_name │ age │ email           │
├────┼───────────┼─────┼─────────────────┤
│ 1  │ Emma      │ 10  │ emma@school.com │
│ 2  │ Liam      │ 11  │ liam@school.com │
└────┴───────────┴─────┴─────────────────┘

5️⃣ Entity Lifecycle

The Journey of an Entity

Every entity goes through a lifecycle - like a butterfly! 🦋

graph TD
    A["🥚 New Object"] -->|persist| B["📦 Managed"]
    B -->|detach| C["🔓 Detached"]
    B -->|remove| D["🗑️ Removed"]
    C -->|merge| B

    style A fill:#ffeaa7,color:#000
    style B fill:#55efc4,color:#000
    style C fill:#74b9ff,color:#000
    style D fill:#fd79a8,color:#000

Lifecycle Operations

Code Examples

Creating (persist)

Student emma = new Student();
emma.setName("Emma");
em.persist(emma);  // Now saved!

Reading (find)

Student found = em.find(Student.class, 1L);
System.out.println(found.getName());

Updating (merge)

emma.setAge(11);  // Change something
em.merge(emma);   // Save changes

Deleting (remove)

em.remove(emma);  // Gone forever!

6️⃣ Entity States

The Four States

Every entity is in one of four states at any moment:

State Transitions Explained

graph TD
    subgraph "Not in Database"
    N["🆕 NEW"]
    end

    subgraph "In Database"
    M["✅ MANAGED"]
    D["🔓 DETACHED"]
    R["🗑️ REMOVED"]
    end

    N -->|"persist#40;#41;"| M
    M -->|"detach#40;#41; or close#40;#41;"| D
    M -->|"remove#40;#41;"| R
    D -->|"merge#40;#41;"| M
    R -->|"persist#40;#41;"| M

    style N fill:#ffeaa7,color:#000
    style M fill:#55efc4,color:#000
    style D fill:#74b9ff,color:#000
    style R fill:#fd79a8,color:#000

🆕 NEW State

// Just created - not in database yet
Student emma = new Student();
emma.setName("Emma");
// emma is NEW - no ID, not tracked

✅ MANAGED State

em.persist(emma);
// Now emma is MANAGED!
// - Has an ID
// - Changes are tracked automatically
emma.setAge(10);  // This will be saved!

🔓 DETACHED State

em.detach(emma);
// Now emma is DETACHED
// - Still has data
// - Changes are NOT tracked
emma.setAge(11);  // This WON'T be saved!

🗑️ REMOVED State

em.remove(emma);
// Now emma is REMOVED
// - Will be deleted on commit
// - Still exists in memory temporarily

Why States Matter

Understanding states prevents common bugs:

🎉 You Made It!

You now understand the foundation of Jakarta Persistence:

🚀 Quick Reference

// 1. Create entity
Student s = new Student();      // NEW

// 2. Save it
em.persist(s);                  // MANAGED

// 3. Find it
Student found = em.find(
    Student.class, 1L);         // MANAGED

// 4. Update it
found.setName("New Name");      // Auto-saved!

// 5. Delete it
em.remove(found);               // REMOVED

💡 Remember: JPA is your friendly librarian. Give it your Java objects, and it handles all the database work for you!