Batch Management

🏭 Jakarta EE Batch Management

The Factory Assembly Line of Enterprise Computing

🎬 The Story Begins…

Imagine you run a giant chocolate factory. Every night, after everyone goes home, robots wake up to do important jobs:

• Count all the chocolates made today
• Sort them into boxes
• Check which ones are perfect
• Ship them to stores

This is exactly what Batch Processing does in the computer world! Instead of chocolates, we process thousands or millions of data records while everyone sleeps.

💡 Batch = Big jobs done in chunks, usually when the system is quiet

🧩 The Eight Heroes of Batch Processing

Let’s meet our heroes—each with a special power!

graph TD
    A["🎮 Job Operator"] --> B["📋 Job Repository"]
    B --> C["🔀 Job Flows"]
    C --> D["⚙️ Batchlets"]
    C --> E["📦 Chunk Processing"]
    D --> F["👂 Batch Listeners"]
    E --> F
    F --> G["💾 Checkpoint Mechanisms"]
    C --> H["🔀 Decision Elements"]
    C --> I["🧩 Job Partitioning"]

1️⃣ Batchlets: The Simple Task Workers

What is a Batchlet?

Think of a Batchlet as a single-task robot. You give it ONE job, it does that job, and it’s done!

Real Life Example:

• You tell your little brother: “Please turn off ALL the lights in the house”
• He walks room to room, turns off lights, comes back and says “DONE!”
• That’s a Batchlet!

When to Use Batchlets?

✅ Delete old files ✅ Send a notification ✅ Run a cleanup script ✅ Call an external service once

Code Example

@Named
public class CleanupBatchlet
    extends AbstractBatchlet {

    @Override
    public String process() {
        // Delete files older than 30 days
        deleteOldFiles();
        return "COMPLETED";
    }
}

Key Points:

• Extends AbstractBatchlet
• Override the process() method
• Return a status string

2️⃣ Job Partitioning: Divide and Conquer!

What is Job Partitioning?

Imagine you have 1 million chocolates to wrap. Would you:

• A) Do it alone? (Takes forever! 😫)
• B) Call 10 friends and split the work? (Much faster! 🎉)

Partitioning = Splitting a big job into smaller pieces that run at the same time!

graph TD
    A["📦 1 Million Records"] --> B["Partition 1<br>Records 1-250K"]
    A --> C["Partition 2<br>Records 250K-500K"]
    A --> D["Partition 3<br>Records 500K-750K"]
    A --> E["Partition 4<br>Records 750K-1M"]
    B --> F["🎯 All Done!"]
    C --> F
    D --> F
    E --> F

Code Example

@Named
public class MyPartitionMapper
    implements PartitionMapper {

    @Override
    public PartitionPlan mapPartitions() {
        PartitionPlanImpl plan =
            new PartitionPlanImpl();
        plan.setPartitions(4); // 4 workers!
        return plan;
    }
}

Key Points:

• Use when you have LOTS of data
• Each partition runs independently
• Massively speeds up processing!

3️⃣ Job Flows: The Recipe Book

What is a Job Flow?

A Job Flow is like a recipe that tells the batch job what steps to follow!

Think of making a cake:

1. First, mix ingredients
2. Then, pour into pan
3. Then, bake
4. Finally, add frosting

Each step happens in order.

Flow Types

XML Example

<job id="cakeJob">
  <step id="mix" next="pour"/>
  <step id="pour" next="bake"/>
  <step id="bake" next="frost"/>
  <step id="frost"/>
</job>

Key Points:

• Steps execute in sequence
• Use next to chain steps
• Flows keep everything organized!

4️⃣ Decision Elements: The Traffic Cop

What is a Decision Element?

Imagine a traffic cop at a crossroads:

• 🟢 Green light? Go to Step A!
• 🔴 Red light? Go to Step B!
• 🟡 Yellow light? Stop completely!

Decisions let your batch job choose different paths based on conditions!

graph TD
    A["Process Records"] --> B{Decision:<br>Errors Found?}
    B -->|Yes| C["Run Error Handler"]
    B -->|No| D["Send Success Report"]
    C --> E["End Job"]
    D --> E

Code Example

@Named
public class ErrorDecider
    implements Decider {

    @Override
    public String decide(
        StepExecution[] executions) {

        long errors = countErrors(executions);
        if (errors > 0) {
            return "HAS_ERRORS";
        }
        return "ALL_GOOD";
    }
}

XML Configuration

<decision id="errorCheck" ref="errorDecider">
  <next on="HAS_ERRORS" to="errorStep"/>
  <next on="ALL_GOOD" to="successStep"/>
</decision>

5️⃣ Batch Listeners: The Watchers

What are Batch Listeners?

Think of Listeners as security cameras watching everything:

• 📹 Camera sees someone ENTER the store → logs it
• 📹 Camera sees someone LEAVE → logs it
• 📹 Camera sees something suspicious → alerts!

Listeners watch different moments in your batch job!

Types of Listeners

Code Example

@Named
public class MyJobListener
    implements JobListener {

    @Override
    public void beforeJob() {
        System.out.println(
            "🚀 Job is starting!");
    }

    @Override
    public void afterJob() {
        System.out.println(
            "✅ Job completed!");
    }
}

Key Points:

• Add logging, metrics, alerts
• Don’t change job logic here
• Just observe and report!

6️⃣ Checkpoint Mechanisms: The Save Points

What is a Checkpoint?

Remember playing video games? You reach a checkpoint, and if you fail, you restart from there—not from the beginning!

Batch Checkpoints work the same way!

graph LR
    A["Start"] --> B["Process 1000"]
    B --> C["💾 Checkpoint!"]
    C --> D["Process 1000 more"]
    D --> E["💾 Checkpoint!"]
    E --> F["Process 1000 more"]
    F --> G["Done!"]

    style C fill:#90EE90
    style E fill:#90EE90

Why Checkpoints Matter?

Without checkpoint:

• Process 5 million records
• Fails at record 4,999,999
• Start over from record 1 😭

With checkpoint:

• Process 5 million records
• Checkpoint every 1000
• Fails at record 4,999,999
• Restart from record 4,999,000 😊

Code Example

@Named
public class MyCheckpointAlgorithm
    implements CheckpointAlgorithm {

    int count = 0;

    @Override
    public boolean isReadyToCheckpoint() {
        count++;
        return count % 1000 == 0;
    }
}

Key Points:

• Save progress regularly
• Enables restart from failure
• Protects against data loss!

7️⃣ Job Repository: The Memory Bank

What is a Job Repository?

The Job Repository is like your diary that remembers everything:

• 📝 What jobs ran?
• 📝 When did they run?
• 📝 Did they succeed or fail?
• 📝 What was the last checkpoint?

What It Stores

graph TD
    A["Job Repository"] --> B["Job Instances"]
    A --> C["Job Executions"]
    A --> D["Step Executions"]
    A --> E["Checkpoints"]

    B --> F["Which jobs exist"]
    C --> G["When jobs ran"]
    D --> H["Step details"]
    E --> I["Progress saved"]

How It Helps

Key Points:

• Automatically managed
• Persists across restarts
• Essential for reliability!

8️⃣ Job Operator: The Boss

What is the Job Operator?

The Job Operator is the BIG BOSS who controls everything:

• 🎬 “START that job!”
• ⏹️ “STOP that job!”
• 🔁 “RESTART that job!”
• 📊 “Tell me the STATUS!”

Key Methods

// Get the boss
JobOperator operator =
    BatchRuntime.getJobOperator();

// Start a job
long executionId =
    operator.start("myJob", props);

// Stop a running job
operator.stop(executionId);

// Restart a failed job
operator.restart(executionId, props);

// Check status
JobExecution exec =
    operator.getJobExecution(executionId);
System.out.println(exec.getBatchStatus());

Job Lifecycle

graph LR
    A["STARTING"] --> B["STARTED"]
    B --> C["STOPPING"]
    C --> D["STOPPED"]
    B --> E["COMPLETED"]
    B --> F["FAILED"]
    F --> G["RESTARTING"]
    G --> B

🎭 Putting It All Together

Here’s how our 8 heroes work together:

graph TD
    A["👨‍💼 Job Operator<br>Starts the job"] --> B["📋 Job Repository<br>Records everything"]
    B --> C["🔀 Job Flow<br>Follows the recipe"]
    C --> D{🚦 Decision<br>Which path?}
    D -->|Path A| E["⚙️ Batchlet&lt;br&gt;Simple task"]
    D -->|Path B| F["🧩 Partitioned Step&lt;br&gt;Split work"]
    E --> G["👂 Listeners&lt;br&gt;Watch &amp; report"]
    F --> G
    G --> H["💾 Checkpoint&lt;br&gt;Save progress"]
    H --> I["✅ Complete!"]

🚀 Quick Reference

💪 You’ve Got This!

Batch processing might sound scary, but remember:

🎯 It’s just like running a factory at night—automated, efficient, and reliable!

Each component has ONE job:

• Batchlets do simple tasks
• Partitioning speeds things up
• Flows keep order
• Decisions choose paths
• Listeners watch everything
• Checkpoints save progress
• Repository remembers all
• Operator controls it all

Now go build amazing batch applications! 🏆