DEV Community: Sadiul Hakim

PHP Laravel Artisan Custom Command

Sadiul Hakim — Wed, 28 Jan 2026 11:57:20 +0000

What is Laravel Artisan?

Artisan is Laravel’s command-line interface (CLI).

It lets you:

Run framework commands (migrate, route:list, cache:clear)
Generate code (make:model, make:controller)
Create your own commands for automation, scripts, cron jobs, maintenance, etc.

Run it from your project root:

php artisan

You’ll see a big list of commands — your custom commands live here too.

Why create custom Artisan commands?

Custom commands are great for:

Data imports
Maintenance scripts
Batch jobs
Cron jobs
Admin tools
One-time scripts
Developer utilities

Think of them as backend CLI tools for your app.

Creating a Custom Command

Laravel gives you a generator.

php artisan make:command GreetUser

This creates:

app/Console/Commands/GreetUser.php

Anatomy of a Command

Open the file

<?php

namespace App\Console\Commands;

use Illuminate\Console\Command;

class GreetUser extends Command
{
    // The command name & signature
    protected $signature = 'greet:user';

    // Description shown in `php artisan list`
    protected $description = 'Greet a user via the console';

    // Command logic
    public function handle()
    {
        $this->info('Hello from Laravel!');
    }
}

Run it:

php artisan greet:user

Boom. Your first custom command.

Command Signature (Arguments & Options)

The signature defines how the command is called.

Basic argument

protected $signature = 'greet:user {name}';

Run:

php artisan greet:user Sadiul

Access it:

$name = $this->argument('name');

Optional argument

protected $signature = 'greet:user {name?}';

Option (flags)

protected $signature = 'greet:user {name} {--shout}';

Run:

php artisan greet:user Sadiul --shout

Check:

if ($this->option('shout')) {
    // do something
}

Taking Text Input (Interactive)

Laravel has built-in prompts (very nice UX).

Ask for input

$name = $this->ask('What is your name?');

Ask with default

$name = $this->ask('Your name?', 'Guest');

Ask secretly (passwords)

$password = $this->secret('Enter password');

Confirm (Yes / No)

if ($this->confirm('Do you want to continue?')) {
    $this->info('Continuing...');
} else {
    $this->warn('Cancelled');
}

Multiple Choice (Single Select)

$role = $this->choice(
    'Select a role',
    ['Admin', 'Editor', 'User'],
    2 // default index
);

User sees:

Select a role:
  [0] Admin
  [1] Editor
  [2] User

Output Helpers (Very Important)

$this->info('Success message');
$this->warn('Warning message');
$this->error('Error message');
$this->line('Plain text');

Tables

$this->table(
    ['ID', 'Name'],
    [
        [1, 'Alice'],
        [2, 'Bob'],
    ]
);

Full Sample Command (REALISTIC)

Create it

php artisan make:command CreateUserCli

Code: `app/Console/Commands/CreateUserCli.php`

<?php

namespace App\Console\Commands;

use Illuminate\Console\Command;

class CreateUserCli extends Command
{
    protected $signature = 'user:create 
                            {name? : User name}
                            {--admin : Create as admin}';

    protected $description = 'Create a user via CLI';

    public function handle()
    {
        // Argument or prompt
        $name = $this->argument('name') 
            ?? $this->ask('Enter user name');

        // Email input
        $email = $this->ask('Enter email');

        // Password input
        $password = $this->secret('Enter password');

        // Role selection
        $role = $this->choice(
            'Select role',
            ['Admin', 'Editor', 'User'],
            2
        );

        // Confirmation
        if (! $this->confirm('Create this user?')) {
            $this->warn('Operation cancelled');
            return Command::FAILURE;
        }

        // Simulate save
        $this->info('User created successfully!');
        $this->table(
            ['Field', 'Value'],
            [
                ['Name', $name],
                ['Email', $email],
                ['Role', $role],
            ]
        );

        return Command::SUCCESS;
    }
}

Run it

php artisan user:create

php artisan user:create Sadiul --admin

Exit Codes (Pro Tip)

return Command::SUCCESS; // 0
return Command::FAILURE; // 1

Useful for cron jobs & scripts.

Where Commands Are Registered?

Laravel auto-registers commands in:

app/Console/Kernel.php

Unless you’re doing something custom — you usually don’t touch this.

Common Real-World Uses

php artisan import:csv
php artisan cleanup:logs
php artisan sync:users
php artisan system:health-check
php artisan cron:run-jobs

DFS and BFS algorithm in php

Sadiul Hakim — Mon, 12 Jan 2026 07:15:38 +0000

1. Problem Setup (Tree Structure)

A generic tree (not binary):

class Node
{
    public function __construct(
        public int $value,
        public array $children = []
    ) {}
}

Tree Visualization

                10
        ┌───────┼────────┬────────┐
        1       2        3        4
        |       |        |     ┌──┴──┐
        5       6        7     8     9

2. BFS (Breadth First Search)

What BFS Means

BFS visits nodes level by level
→ First root
→ Then all children
→ Then grandchildren

Key Data Structure: Queue
Rule: First In → First Out (FIFO)

BFS Algorithm (Concept)

Put root node into the queue
While queue is not empty:

Remove the front node
Process it
Add all its children to the queue

BFS Code (Your Example, Explained)

$queue = new SplQueue();
$queue->enqueue($root);

while (!$queue->isEmpty()) {

    // Step 1: Take node from front
    $node = $queue->dequeue();

    // Step 2: Process node
    echo $node->value . "<br/>";

    // Step 3: Add children to queue
    foreach ($node->children as $child) {
        $queue->enqueue($child);
    }
}

BFS Execution Order (Step by Step)

Queue State	Current Node	Output
[10]	10	10
[1,2,3,4]	1	1
[2,3,4,5]	2	2
[3,4,5,6]	3	3
[4,5,6,7]	4	4
[5,6,7,8,9]	5	5
[6,7,8,9]	6	6
[7,8,9]	7	7
[8,9]	8	8
[9]	9	9

BFS Output

10 1 2 3 4 5 6 7 8 9

When to Use BFS

Level-based traversal
Shortest path in unweighted graphs
Tree level order printing

3. DFS (Depth First Search)

What DFS Means

DFS goes as deep as possible before coming back

Key Data Structure: Stack
Rule: Last In → First Out (LIFO)

DFS Algorithm (Iterative)

Push root node into stack
While stack is not empty:

Pop top node
Process it
Push its children in reverse order

Why reverse?
So left children are processed first (natural order).

DFS Code Using `SplStack`

$stack = new SplStack();
$stack->push($root);

while (!$stack->isEmpty()) {

    // Step 1: Take top node
    $node = $stack->pop();

    // Step 2: Process node
    echo $node->value . "<br/>";

    // Step 3: Push children (reverse order)
    for ($i = count($node->children) - 1; $i >= 0; $i--) {
        $stack->push($node->children[$i]);
    }
}

DFS Execution Order (Step by Step)

Stack State	Current Node	Output
[10]	10	10
[4,3,2,1]	1	1
[4,3,2,5]	5	5
[4,3,2]	2	2
[4,3,6]	6	6
[4,3]	3	3
[4,7]	7	7
[4]	4	4
[9,8]	8	8
[9]	9	9

DFS Output

10 1 5 2 6 3 7 4 8 9

When to Use DFS

Tree recursion replacement
Path exploration
Backtracking
Topological traversal

4. DFS Using Recursion (Classic)

function dfs(Node $node)
{
    echo $node->value . "<br/>";

    foreach ($node->children as $child) {
        dfs($child);
    }
}

dfs($root);

Why Stack Version Is Better in PHP

No stack overflow for deep trees
Full control over traversal
Better for interviews and real systems

5. BFS vs DFS (Quick Comparison)

Feature	BFS	DFS
Data Structure	Queue	Stack
Traversal	Level by level	Deep first
Memory	Higher	Lower
Shortest Path	Yes	No
Implementation	Iterative	Recursive or Iterative

6. Key Takeaways

Queue controls BFS
Stack controls DFS
Traversal order is defined by data structure behavior
SPL (SplQueue, SplStack) is standard and efficient

PHP SPL: Stack and Queue Tutorial

Sadiul Hakim — Mon, 12 Jan 2026 06:56:47 +0000

1. What is SPL?

SPL (Standard PHP Library) is a collection of built-in data structures and interfaces designed to solve common problems efficiently.

Why use SPL?

Better performance than custom arrays
Clear intent (stack vs queue)
Cleaner, more readable code

We’ll focus on:

SplStack
SplQueue

2. Stack vs Queue (Concept)

Stack (LIFO)

Last In, First Out
Examples:
- Undo/Redo
- Function call stack
- Browser back button

Queue (FIFO)

First In, First Out
Examples:
- Job processing
- Task scheduling
- Message queues

3. SplStack

3.1 Creating a Stack

$stack = new SplStack();

3.2 Pushing Elements (push)

$stack->push("A");
$stack->push("B");
$stack->push("C");

Stack state:

Top -> C
       B
Bottom-> A

3.3 Popping Elements (pop)

echo $stack->pop(); // C

Explanation:

Removes and returns the top element.

3.4 Peeking Top Element (top)

echo $stack->top(); // B

Reads top element without removing it.

3.5 Checking if Stack is Empty

if ($stack->isEmpty()) {
    echo "Stack is empty";
}

3.6 Counting Elements

echo $stack->count(); // number of elements

3.7 Iterating a Stack

Important:

SplStack iterates from top to bottom by default.

foreach ($stack as $item) {
    echo $item . PHP_EOL;
}

3.8 Real-World Example: Undo Feature

$undoStack = new SplStack();

$undoStack->push("Typed 'Hello'");
$undoStack->push("Typed 'World'");
$undoStack->push("Deleted 'World'");

// User presses undo
echo $undoStack->pop(); // Deleted 'World'

4. SplQueue

4.1 Creating a Queue

$queue = new SplQueue();

4.2 Enqueue (add to queue)

$queue->enqueue("Job1");
$queue->enqueue("Job2");
$queue->enqueue("Job3");

Queue state:

Front -> Job1, Job2, Job3 -> Back

4.3 Dequeue (remove from queue)

echo $queue->dequeue(); // Job1

Removes and returns the first element.

4.4 Peeking Front Element

echo $queue->bottom(); // Job2

Explanation:

bottom() → front of the queue
top() → back of the queue

4.5 Checking if Queue is Empty

if ($queue->isEmpty()) {
    echo "Queue is empty";
}

4.6 Counting Elements

echo $queue->count();

4.7 Iterating a Queue

foreach ($queue as $job) {
    echo $job . PHP_EOL;
}

Iteration order:

Front → Back

4.8 Real-World Example: Job Processing

$jobQueue = new SplQueue();

// Add jobs
$jobQueue->enqueue("Send Email");
$jobQueue->enqueue("Generate Invoice");
$jobQueue->enqueue("Notify User");

// Process jobs
while (!$jobQueue->isEmpty()) {
    $job = $jobQueue->dequeue();
    echo "Processing: $job" . PHP_EOL;
}

5. Stack vs Queue Summary

Feature	SplStack	SplQueue
Order	LIFO	FIFO
Add	push()	enqueue()
Remove	pop()	dequeue()
Typical Use	Undo, recursion	Jobs, tasks

6. Common Mistakes

❌ Using arrays instead of SPL

array_push($stack, $value); // Not recommended

Why?

Slower
Less expressive
Easy to misuse order

Use SPL instead.

❌ Confusing top() and bottom() in Queue

bottom() → front
top() → back

7. When to Use SPL in Laravel / PHP Apps

Use SplStack when:

Undo/redo
Nested operations
Temporary reversal logic

Use SplQueue when:

Sequential jobs
Rate-limited API calls
Background task pipelines

Laravel internal usage:

Symfony (Laravel’s base) uses SPL structures heavily.

8. Performance Note

SPL structures are implemented in C
Faster than PHP arrays for stack/queue operations
Less memory overhead for frequent push/pop

9. Quick Cheat Sheet

// Stack
$stack->push($item);
$stack->pop();
$stack->top();

// Queue
$queue->enqueue($item);
$queue->dequeue();
$queue->bottom();

Laravel Artisan Commands – Practical Tutorial

Sadiul Hakim — Sun, 11 Jan 2026 06:49:24 +0000

php artisan is Laravel’s command-line interface. It helps you generate code, manage the app lifecycle, work with the database, debug, and maintain the project efficiently.

1. Controller Commands

1.1 Basic Controller

php artisan make:controller UserController

What it does

Creates an empty controller class in app/Http/Controllers

Use case

When you want full control and plan to manually define methods.

Example

class UserController extends Controller {
    public function index() {}
    public function store() {}
}

1.2 Resource Controller

php artisan make:controller UserController --resource

What it generates

A controller with CRUD methods

Methods included:

index()
create()
store()
show()
edit()
update()
destroy()

Use case

Best for MVC web apps
Works perfectly with:

Route::resource('users', UserController::class);

1.3 API Resource Controller

php artisan make:controller UserController --api

Difference from --resource

Removes UI-related methods:
- ❌ create()
- ❌ edit()

Use case

REST APIs (JSON only)
Common in Sanctum / JWT based APIs

1.4 Invokable Controller

php artisan make:controller UserController --invokable

What it creates

A controller with only __invoke()

Use case

Single-responsibility routes
Clean and readable for small actions

Example

Route::post('/login', LoginController::class);

2. View & UI Related Commands

2.1 Create a Blade View

php artisan make:view about

Creates

resources/views/about.blade.php

Use case

Quickly scaffold views for pages

2.2 Blade Component

php artisan make:component About

Creates

Component class
Blade view

Use case

Reusable UI elements
Headers, buttons, modals

Example

<x-about />

3. Model & Database Layer

3.1 Create Model

php artisan make:model Course

Creates

app/Models/Course.php

Common variants

php artisan make:model Course -m   # with migration
php artisan make:model Course -f   # with factory
php artisan make:model Course -s   # with seeder
php artisan make:model Course -a   # all

3.2 Show Model Info (Laravel 10+)

php artisan model:show Course

Displays

Table name
Columns
Relationships
Casts

Use case

Debugging models
Understanding schema quickly

4. Migration Commands

4.1 Create Migration

php artisan make:migration create_posts_table

Creates

database/migrations/xxxx_create_posts_table.php

4.2 Run Migrations

php artisan migrate

Use case

Apply schema changes

4.3 Rollback Migrations

php artisan migrate:rollback --step=3

Use case

Undo last 3 migrations

4.4 Reset All Migrations

php artisan migrate:reset

Danger

Drops all tables

4.5 Refresh Migrations

php artisan migrate:refresh

Does

Rollback + re-run migrations

Useful during development.

4.6 Run a Specific Migration

php artisan migrate --path=/database/migrations/2026_01_04_150744_create_teachers_table.php

Use case

Fixing or testing one migration

5. Seeder & Database Data

5.1 Create Seeder

php artisan make:seeder TeachersSeeder

5.2 Run Seeder

php artisan db:seed --class=TeachersSeeder

Use case

Insert test or default data

6. Validation, Middleware, Security

6.1 Custom Validation Rule

php artisan make:rule Uppercase

Use case

Reusable complex validation logic

6.2 Middleware

php artisan make:middleware CheckRole

Use case

Authentication
Authorization
Request filtering

7. Authentication & API

7.1 Install API Authentication

php artisan install:api

Installs

Laravel Sanctum
API auth scaffolding

7.2 Auth Service Provider

php artisan make:provider AuthServiceProvider

Use case

Define Gates & Policies
Authorization logic

8. Mail & Communication

8.1 Create Mail Class

php artisan make:mail WelcomeMail

Use case

Emails
Notifications

9. Application Setup & Maintenance

9.1 Generate App Key

php artisan key:generate

Must run

After cloning a project
Required for encryption, sessions, cookies

9.2 Storage Symlink

php artisan storage:link

Purpose

Makes storage/app/public accessible from browser

Use case

File uploads
Images

9.3 Maintenance Mode

php artisan down
php artisan down --secret="token"
php artisan up

Use case

Deployment
Server maintenance

10. Routing & Debugging

10.1 List Routes

php artisan route:list

php artisan route:list --except-vendor

Use case

Debug route conflicts
Check middleware, methods

11. Localization & Stubs

11.1 Enable Localization

php artisan lang:publish

Creates

lang/en/

Use case

Multi-language apps

11.2 Publish Stubs

php artisan stub:publish

What is a stub?

Template used by make: commands

Use case

Customize default controllers, models, migrations

12. Cache & Optimization

php artisan optimize
php artisan optimize:clear
php artisan config:cache
php artisan route:cache
php artisan view:clear

Use case

Production performance
Fix weird cache bugs

13. Queue & Jobs

php artisan make:job SendEmailJob
php artisan queue:work

14. Policy

php artisan make:policy CoursePolicy --model=Course

15. Tinker (Very Important)

php artisan tinker

Use case

Run Laravel code interactively
Debug models, queries, services

Java JOLT built in functions

Sadiul Hakim — Tue, 25 Nov 2025 02:47:29 +0000

=intSum
=doubleSum
=toString
=toInteger
=toLong
=toDouble
=toBoolean
=size, '=sort'
=join
=substring
=abs, =avg, =min, '=max'

These functions work only inside modify-overwrite-beta or modify-default-beta operations.

1. JOLT Modify Operations Overview

There are two modify operations:

1. modify-overwrite-beta

Replaces the existing value
Can use functions (=intSum, =multiply, etc.)
Used for math/string/date transformations

2. modify-default-beta

Only sets value if missing
Good for default initialization

How to use functions?

Syntax:

"fieldName": "=functionName(arg1, arg2, ...)"

Arguments can be:

Literal values
JSON values referenced via @(n,key)
Other function outputs

--------------------------------------

2. MATH FUNCTIONS

--------------------------------------

2.1 =intSum, =doubleSum

Add multiple numbers.

Input

{
  "price": 100,
  "tax": 15
}

Spec

[
  {
    "operation": "modify-overwrite-beta",
    "spec": {
      "total": "=intSum(@(1,price), @(1,tax))"
    }
  }
]

Output

{
  "price": 100,
  "tax": 15,
  "total": 115
}

2.2 =abs

Input

{
  "num": -12.7
}

Spec

[
  {
    "operation": "modify-overwrite-beta",
    "spec": {
      "absVal": "=abs(@(1,num))",

    }
  }
]

Output

{
  "num": -12.7,
  "absVal": 12.7,
}

--------------------------------------

3. STRING FUNCTIONS

--------------------------------------

3.1 =toString

Input

{
  "id": 42
}

Spec

[
  {
    "operation": "modify-overwrite-beta",
    "spec": {
      "idString": "=toString(@(1,id))"
    }
  }
]

Output

{
  "id": 42,
  "idString": "42"
}

3.2 =join (concatenate strings)

Input

{
  "first": "John",
  "last": "Wick"
}

Spec

[
  {
    "operation": "modify-overwrite-beta",
    "spec": {
      "fullName": "=join(' ', @(1,first), @(1,last))"
    }
  }
]

Output

{
  "first": "John",
  "last": "Wick",
  "fullName": "John Wick"
}

3.3 =substring

Syntax:

"field": "=substring(value, startIndex, endIndex)"

Input

{
  "code": "ABCDEF"
}

Spec

[
  {
    "operation": "modify-overwrite-beta",
    "spec": {
      "sub": "=substring(@(1,code), 1, 4)"
    }
  }
]

Output

{
  "code": "ABCDEF",
  "sub": "BCD"
}

--------------------------------------

4. TYPE CASTING FUNCTIONS

--------------------------------------

=toInteger, =toLong, =toDouble, =toBoolean

Input

{
  "price": "100",
  "pi": "3.14",
  "flag": "true"
}

Spec

[
  {
    "operation": "modify-overwrite-beta",
    "spec": {
      "priceInt": "=toInteger(@(1,price))",
      "piDouble": "=toDouble(@(1,pi))",
      "flagBool": "=toBoolean(@(1,flag))"
    }
  }
]

Output

{
  "price": "100",
  "pi": "3.14",
  "flag": "true",
  "priceInt": 100,
  "piDouble": 3.14,
  "flagBool": true
}

--------------------------------------

5. ARRAY FUNCTIONS

--------------------------------------

=size()

Input

{
  "items": ["a", "b", "c"]
}

Spec

[
  {
    "operation": "modify-overwrite-beta",
    "spec": {
      "count": "=size(@(1,items))"
    }
  }
]

Output

{
  "items": ["a", "b", "c"],
  "count": 3
}

=sort()

Input

{
  "items": [5, 3, 2, 4]
}

Spec

[
  {
    "operation": "modify-overwrite-beta",
    "spec": {
      "sorted": "=sort(@(1,items))"
    }
  }
]

Output

{
  "items": [5, 3, 2, 4]
  "sorted": [2,3,4,5]
}

--------------------------------------

6. CHAINING MULTIPLE FUNCTIONS

--------------------------------------

Example:

Take a string "100", convert to int, add tax, then format as text.

Input

{
  "value": "100"
}

Spec

[
  {
    "operation": "modify-overwrite-beta",
    "spec": {
      "final": "=join(' USD', intSum(toInteger(@(1,value)), 15))"
    }
  }
]

Output

{
  "value": "100",
  "final": "115 USD"
}

--------------------------------------

7. MASTER LIST — All JOLT Functions

--------------------------------------

Math

=abs
=avg
=min
=max
=intSum
=doubleSum

String

=join
=toString
=substring

Casting

=toInteger
=toLong
=toDouble
=toBoolean

Array

=size
=sort

Java JOLT Examples..

Sadiul Hakim — Tue, 25 Nov 2025 02:41:16 +0000

1. REAL-WORLD JOLT PATTERNS

These patterns cover 95% of JSON transformation tasks.

Pattern 1 — Flattening deep JSON into simple key/value JSON

Input

{
  "user": {
    "profile": {
      "name": "Alice",
      "age": 30
    },
    "address": {
      "city": "Dhaka",
      "zip": "1000"
    }
  }
}

Spec

[
  {
    "operation": "shift",
    "spec": {
      "user": {
        "profile": {
          "name": "name",
          "age": "age"
        },
        "address": {
          "city": "city",
          "zip": "zip"
        }
      }
    }
  }
]

Output

{
  "name": "Alice",
  "age": 30,
  "city": "Dhaka",
  "zip": "1000"
}

Pattern 2 — Flatten unknown dynamic keys

Input

{
  "env": {
    "JAVA_HOME": "/opt/java",
    "PATH": "/bin:/usr/bin",
    "USER": "root"
  }
}

Spec

[
  {
    "operation": "shift",
    "spec": {
      "env": {
        "*": "&"       // & means “copy key name"
      }
    }
  }
]

Output

{
  "JAVA_HOME": "/opt/java",
  "PATH": "/bin:/usr/bin",
  "USER": "root"
}

Pattern 3 — Flatten Array of Objects → Map by ID

Very common in backend transformations.

Input

{
  "products": [
    { "id": 1, "name": "Pen", "price": 10 },
    { "id": 2, "name": "Notebook", "price": 30 }
  ]
}

Spec

[
  {
    "operation": "shift",
    "spec": {
      "products": {
        "*": {
          "@": "productMap.@(1,id)"
        }
      }
    }
  }
]

Explanation

* → iterate array
@ → copy entire object
@(1,id) → read parent object’s id and use as map key

Output

{
  "productMap": {
    "1": { "id": 1, "name": "Pen", "price": 10 },
    "2": { "id": 2, "name": "Notebook", "price": 30 }
  }
}

Pattern 4 — Grouping items by category

Input

{
  "items": [
    { "name": "Fish", "type": "Food" },
    { "name": "Apple", "type": "Food" },
    { "name": "Shirt", "type": "Clothes" }
  ]
}

Spec

[
  {
    "operation": "shift",
    "spec": {
      "items": {
        "*": {
          "@": "grouped.@(1,type)[]"
        }
      }
    }
  }
]

Explanation:

@(1,type) → read the type dynamically
[ ] → append to array

Output

{
  "grouped": {
    "Food": [
      { "name": "Fish", "type": "Food" },
      { "name": "Apple", "type": "Food" }
    ],
    "Clothes": [
      { "name": "Shirt", "type": "Clothes" }
    ]
  }
}

Pattern 5 — Filter array items based on value

⚠ JOLT cannot do conditional filtering directly (no "if"),
BUT you can simulate filtering by mapping only the matching items.

Example: Keep only items where "active": true.

Input

{
  "users": [
    { "id": 1, "name": "A", "active": true },
    { "id": 2, "name": "B", "active": false },
    { "id": 3, "name": "C", "active": true }
  ]
}

Spec

This keeps only active==true.

[
  {
    "operation": "shift",
    "spec": {
      "users": {
        "*": {
          "active": {
            "true": {
              "@2": "activeUsers[]"
            }
          }
        }
      }
    }
  }
]

Explanation

@2 = go 2 levels up → the whole user object
Only items where "active": "true" map successfully

Output

{
  "activeUsers": [
    { "id": 1, "name": "A", "active": true },
    { "id": 3, "name": 3, "active": true }
  ]
}

Pattern 6 — Reorder and rename fields

Input

{
  "id": 10,
  "first": "Alice",
  "last": "Wonder"
}

Spec

[
  {
    "operation": "shift",
    "spec": {
      "id": "user.id",
      "first": "user.name.first",
      "last": "user.name.last"
    }
  }
]

Output

{
  "user": {
    "id": 10,
    "name": {
      "first": "Alice",
      "last": "Wonder"
    }
  }
}

Pattern 7 — Add default values

Spec

[
  {
    "operation": "default",
    "spec": {
      "status": "ACTIVE",
      "roles": ["USER"]
    }
  }
]

Useful in user creation APIs.

Pattern 8 — Selective removal of fields

Spec

[
  {
    "operation": "remove",
    "spec": {
      "internalId": "",
      "debug": ""
    }
  }
]

Pattern 9 — Math and string operations

Using modify-overwrite-beta.

Input

{
  "price": 100,
  "tax": 15
}

Spec

[
  {
    "operation": "modify-overwrite-beta",
    "spec": {
      "total": "=intSum(@(1,price), @(1,tax))"
    }
  }
]

Output

{
  "price": 100,
  "tax": 15,
  "total": 115
}

Pattern 10 — Transform list of values to objects

Input

{
  "tags": ["red", "blue", "green"]
}

Spec

[
  {
    "operation": "shift",
    "spec": {
      "tags": {
        "*": {
          "@": "list[]",
          "$": "list[].name"
        }
      }
    }
  }
]

Output

{
  "list": [
    { "name": "red" },
    { "name": "blue" },
    { "name": "green" }
  ]
}

2. INTERACTIVE EXAMPLES

These help you understand JOLT step-by-step.

Interactive Example 1: Dynamic key renaming

Input

{
  "meta": {
    "user_id": 5,
    "user_role": "admin"
  }
}

Goal

Convert keys from snake_case → camelCase.

Spec

[
  {
    "operation": "shift",
    "spec": {
      "meta": {
        "user_*": "user.&(0,1)"
      }
    }
  }
]

Explanation:

user_* matches → user_id, user_role
&(0,1) takes the part after the underscore
- id
- role

Output

{
  "user": {
    "id": 5,
    "role": "admin"
  }
}

Interactive Example 2: Pick fields based on dynamic index

Input

{
  "data": [
    { "name": "A", "score": 80 },
    { "name": "B", "score": 90 }
  ]
}

Want → convert list to key/value

Spec

[
  {
    "operation": "shift",
    "spec": {
      "data": {
        "*": {
          "score": "scores.@(2,name)"
        }
      }
    }
  }
]

Explanation:

@(2,name) goes 2 levels up → reads the "name"

Output

{
  "scores": {
    "A": 80,
    "B": 90
  }
}

Interactive Example 3 — Conditional grouping by value

Input

{
  "items": [
    { "name": "Book", "type": "A", "price": 20 },
    { "name": "Pen", "type": "B", "price": 5 },
    { "name": "Bag", "type": "A", "price": 100 }
  ]
}

Spec

[
  {
    "operation": "shift",
    "spec": {
      "items": {
        "*": {
          "@": "group.@(1,type)[]"
        }
      }
    }
  }
]

Output

group:
  A:
    - Book
    - Bag
  B:
    - Pen

Java JOLT library tutorial with Examples

Sadiul Hakim — Sat, 22 Nov 2025 09:20:26 +0000

1. What is JOLT?

JOLT (JSON-to-JSON Transformation) is an open-source Java library (originally from Bazel/Spotify) used to:

✔ Transform JSON into a different JSON
✔ Restructure fields
✔ Rename keys
✔ Change nesting
✔ Flatten or unflatten
✔ Filter fields
✔ Dynamically map values
✔ Build complex transformation pipelines

JOLT uses a transformation spec, written as JSON, to tell how input JSON should be transformed.

2. Why and When to Use JOLT?

Use JOLT when:

Your application needs to convert JSON from one format to another

Examples:

Backend receives API JSON and needs to convert it to another JSON format.
Integrating with 3rd-party APIs that return weird JSON structure.

You don’t want to write manual JSON parsing/conversion

Without JOLT you'd write dozens of lines of ObjectMapper, maps, loops, etc.

JOLT reduces this to a tiny JSON transformation spec.

You want data transformation configurable — not hardcoded

You can store the spec in:

a file,
a database,
config properties,
or generate dynamically.

3. What is a Spec?

A spec is a JSON array describing transformation steps.

Example:

[
  {
    "operation": "shift",
    "spec": {
      "user": {
        "name": "username"
      }
    }
  }
]

This means:

user.name  →  username

4. JOLT Operations

Operation	Purpose
shift	Move fields from input to output (mapping).
default	Add missing fields with default values.
remove	Remove fields.
sort	Sort JSON keys.
cardinality	Force single-item arrays or multi-item arrays.
modify-overwrite-beta	Modify values (math, string concat, etc.).
modify-default-beta	Modify or add default values.

Most commonly used = shift.

5. Using Spec from File, String, Java Object

A) Spec from `.json` file

List<Object> specs = JsonUtils.filepathToList("spec.json");
Chainr chainr = Chainr.fromSpec(specs);
Object output = chainr.transform(inputJson);

B) Spec from JSON String

String specJson = "[ { \"operation\": \"shift\", \"spec\": {\"a\":\"b\"} } ]";
List<Object> specs = JsonUtils.jsonToList(specJson);
Chainr chainr = Chainr.fromSpec(specs);

C) Spec as Java object

List<Object> specs = new ArrayList<>();

Map<String, Object> shiftOp = new HashMap<>();
shiftOp.put("operation", "shift");

Map<String, Object> shiftSpec = new HashMap<>();
shiftSpec.put("a", "b");

shiftOp.put("spec", shiftSpec);

specs.add(shiftOp);

Chainr chainr = Chainr.fromSpec(specs);

6. Explanation of JOLT Symbols (`@`, `$`, `&`)

These symbols are used inside shift mapping.

@ → Value reference

Points to value of current key.

Input:

{ "name": "John" }

Spec:

{
  "name": "personName.@"
}

Output:

{
  "personName": "John"
}

$ → Key reference

Refers to the current key name.

Input:

{ "a": 10, "b": 20 }

Spec:

"*": "result.&"

Output:

{
  "result": {
    "a": 10,
    "b": 20
  }
}

& → Copy matched key name

Similar to $ but used inside array indexing or deep nesting.

Input:

{ "items": { "101": "Book", "102": "Pen" } }

Spec:

{
  "items": {
    "*": "products.&"
  }
}

Output:

{
  "products": {
    "101": "Book",
    "102": "Pen"
  }
}

7. Working With JSON Objects and Arrays

Example input with arrays

{
  "users": [
    { "id": 1, "name": "A" },
    { "id": 2, "name": "B" }
  ]
}

Spec: convert list → map by id

[
  {
    "operation": "shift",
    "spec": {
      "users": {
        "*": {
          "@": "usersById.@(1,id)"
        }
      }
    }
  }
]

Explanation:

* → for each array element
@ → copy object
@(1,id) → go 1 level up (the object) and fetch id field → use it as key

Output:

{
  "usersById": {
    "1": { "id": 1, "name": "A" },
    "2": { "id": 2, "name": "B" }
  }
}

8. Full Implementation in Java (Real Example)

Maven dependency

<dependency>
  <groupId>com.bazaarvoice.jolt</groupId>
  <artifactId>jolt-core</artifactId>
  <version>0.1.8</version>
</dependency>

<dependency>
  <groupId>com.bazaarvoice.jolt</groupId>
  <artifactId>json-utils</artifactId>
  <version>0.1.8</version>
</dependency>

Example Input JSON

{
  "user": {
    "id": 10,
    "first": "John",
    "last": "Doe"
  }
}

Spec Example (shift + default + remove)

spec.json:

[
  {
    "operation": "shift",
    "spec": {
      "user": {
        "id": "id",
        "first": "name.first",
        "last": "name.last"
      }
    }
  },
  {
    "operation": "default",
    "spec": {
      "role": "USER"
    }
  },
  {
    "operation": "remove",
    "spec": {
      "unusedField": ""
    }
  }
]

Java Code

import com.bazaarvoice.jolt.Chainr;
import com.bazaarvoice.jolt.JsonUtils;

import java.util.List;
import java.util.Map;

public class JoltExample {

    public static void main(String[] args) {

        // 1. Load input JSON
        Map<String, Object> input = JsonUtils.jsonToMap(
                "{ \"user\": {\"id\":10, \"first\":\"John\", \"last\":\"Doe\"} }"
        );

        // 2. Load spec from file
        List<Object> specs = JsonUtils.filepathToList("spec.json");

        // 3. Create transformer
        Chainr chainr = Chainr.fromSpec(specs);

        // 4. Transform JSON
        Object output = chainr.transform(input);

        // 5. Print output
        System.out.println(JsonUtils.toJsonString(output));
    }
}

Output

{
  "id": 10,
  "name": {
    "first": "John",
    "last": "Doe"
  },
  "role": "USER"
}

Summary (Cheat Sheet)

Topic	Summary
What is JOLT	JSON transformer library for Java
Why use it	Easy JSON-to-JSON mapping without writing code
Spec	JSON instructions for transformation
Operations	shift, default, remove, modify, sort, cardinality
Symbols	@ value, $ key, & copy name
From file/string/object	Supported
Arrays	Wildcards + operators like `@(1,id)`
Java Implementation	Use Chainr and JsonUtils

Java 25 Structured Concurrency (Preview) — The Complete Guide

Sadiul Hakim — Wed, 05 Nov 2025 11:29:37 +0000

1. What Is Structured Concurrency?

The Problem (Before Java 21)

Traditionally, Java concurrency used tools like:

Thread, ExecutorService, Future, and CompletableFuture.
You’d manually create threads, track them, and handle cancellations or exceptions yourself.

The problem?
It’s hard to manage lifecycles. Threads could outlive their parent logic.
Exceptions might get lost, and cancellation is messy.

Example:

Future<String> f1 = executor.submit(this::task1);
Future<String> f2 = executor.submit(this::task2);

String result1 = f1.get(); // blocks
String result2 = f2.get();

If one fails, the other still runs. You must remember to cancel or handle it.
That’s unstructured concurrency.

The Solution: Structured Concurrency (JEP 453 / Java 21+)

Structured concurrency treats concurrent subtasks as structured blocks,
just like try-with-resources or nested method calls.

All threads are started, joined, and canceled together.
The parent waits for all subtasks to finish.
Exceptions are automatically aggregated and propagated.

Think of it as:

“Concurrency with clean lifecycles — all children finish before the parent exits.”

2. Key Concepts

Concept	Description
`StructuredTaskScope`	A scope that manages subtasks together. It starts, joins, cancels, and aggregates results.
`Subtask`	A unit of work submitted to the scope via `fork()`.
`Joiner`	Defines how the scope joins results — for example, stop after any success, all success, or a custom condition.
`Structured Concurrency`	The programming model — ensures that concurrent tasks are managed as a structured whole.
`Virtual Threads`	Lightweight threads from Project Loom — perfect for structured concurrency since they scale to millions of tasks efficiently.

3. `StructuredTaskScope` in Action

The class StructuredTaskScope manages subtasks:

try (var scope = StructuredTaskScope.open()) {
    var t1 = scope.fork(() -> task("A"));
    var t2 = scope.fork(() -> task("B"));

    scope.join(); // Wait for all subtasks to finish
    System.out.println(t1.get());
    System.out.println(t2.get());
}

When you exit the try block:

All threads are joined.
If any exception occurred, it’s handled properly.
The scope cleans itself up.

4. Built-in Joiners

`allSuccessfulOrThrow()`

Waits for all subtasks to succeed or throws an exception.

try (var scope = StructuredTaskScope.open(allSuccessfulOrThrow())) {
    var t1 = scope.fork(() -> task(2, false));
    var t2 = scope.fork(() -> task(3, true)); // this fails
    scope.join();
}

If any task fails → it throws an exception after joining.

`anySuccessfulResultOrThrow()`

Waits for the first successful task, cancels the rest.

try (var scope = StructuredTaskScope.open(anySuccessfulResultOrThrow())) {
    scope.fork(() -> task(4, false));
    scope.fork(() -> task(2, true));
    scope.fork(() -> task(3, false));

    Object result = scope.join();
    System.out.println(result);
}

As soon as one subtask returns successfully, others are canceled.

Custom Joiner (like `TargetSuccessJoiner`)

You can define your own joining logic using StructuredTaskScope.Joiner.

5. Custom Joiner: `TargetSuccessJoiner`

Let’s understand your custom joiner step-by-step:

static class TargetSuccessJoiner<T> implements StructuredTaskScope.Joiner<T, List<T>> {
    private final int targetCount;
    private final List<T> successfulResults = Collections.synchronizedList(new ArrayList<>());
    private final List<Throwable> exceptions = Collections.synchronizedList(new ArrayList<>());

    TargetSuccessJoiner(int targetCount) {
        this.targetCount = targetCount;
    }

targetCount = how many successful results you want before stopping.
Example: You may only need 2 successful responses from 10 servers.

The `onComplete()` Method

Called when each subtask finishes:

@Override
public boolean onComplete(StructuredTaskScope.Subtask<? extends T> subtask) {
    switch (subtask.state()) {
        case SUCCESS -> {
            System.out.println("Success: " + subtask.get());
            successfulResults.add(subtask.get());
            if (successfulResults.size() >= targetCount) {
                System.out.println("🚦 Reached " + targetCount + " successes — shutting down scope!");
                return true; // stop scope early
            }
        }
        case FAILED -> {
            System.out.println("Failure: " + subtask.exception());
            exceptions.add(subtask.exception());
        }
    }
    return false; // continue waiting
}

Key points:

Each subtask completion is observed.
When enough successes are reached, it ends early.
Failed subtasks are recorded.

The `result()` Method

Called after all tasks have completed or stopped early.

@Override
public List<T> result() throws Throwable {
    if (successfulResults.size() >= targetCount) {
        return List.copyOf(successfulResults);
    } else {
        Exception ex = new Exception("Fewer than " + targetCount + " tasks succeeded");
        exceptions.forEach(ex::addSuppressed);
        throw ex;
    }
}

If not enough successes, it throws an exception with all suppressed errors attached.

6. Full Example: `twoSuccessfulJoiner()`

private static void twoSuccessfulJoiner() {
    try (var scope = StructuredTaskScope.open(new TargetSuccessJoiner<String>(2))) {
        scope.fork(() -> task(4, false));
        scope.fork(() -> task(3, false));
        scope.fork(() -> task(2, true));
        scope.fork(() -> task(5, false));

        List<String> results = scope.join();
        System.out.println("Collected: " + results);
    } catch (Exception ex) {
        ex.printStackTrace();
    }
}

Behavior:

Four tasks run concurrently.
Stop after 2 successes.
Failures are logged but do not prevent others from running.
join() returns a list of successful results.

7. Example Task Method

private static String task(int sec, boolean fail) {
    try {
        TimeUnit.SECONDS.sleep(sec);

        if (fail) throw new RuntimeException("Task Failed");
        return String.format("Task finished in %s sec", sec);
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

This simulates a slow task — either success or failure after a delay.

8. With Timeout Example

try (var scope = StructuredTaskScope.open(allSuccessfulOrThrow(),
        cf -> cf.withTimeout(Duration.ofSeconds(4)))) {
    var t1 = scope.fork(() -> task(4, false));
    var t2 = scope.fork(() -> task(5, false));
    scope.join();
}

If subtasks don’t finish in time, the scope cancels them automatically.

9. Structured Concurrency + Virtual Threads

Structured Concurrency works beautifully with Virtual Threads (Project Loom).

Virtual Threads Recap:

Introduced in Java 21.
Extremely lightweight — you can spawn millions.
Perfect for I/O-bound concurrent tasks.

Example:

try (var scope = StructuredTaskScope.open()) {
    var task1 = scope.fork(() -> Thread.ofVirtual().factory().newThread(() -> task(2, false)));
    var task2 = scope.fork(() -> task(3, false));
    scope.join();
}

In fact, StructuredTaskScope automatically uses virtual threads by default (in most modern JDK versions).

So you get massive scalability + clean structure.

10. Why Use Structured Concurrency?

Benefit	Description
Simplicity	One scope manages all child tasks.
Safety	No thread leaks, no forgotten joins.
Propagated Exceptions	All exceptions bubble up cleanly.
Cancellable	You can stop early (like with `anySuccessfulResultOrThrow` or custom logic).
Works with Virtual Threads	Efficient and scalable.

Final Thoughts

Structured concurrency brings clarity and safety to concurrent Java code:

You can now treat parallel work as structured blocks.
It’s composable, maintainable, and easy to reason about.

Quick Summary

Concept	Purpose
`StructuredTaskScope`	Parent scope for concurrent subtasks
`Subtask`	Individual child computation
`Joiner`	Strategy for combining or short-circuiting results
`Virtual Threads`	Lightweight concurrency engine
Custom Joiner	Define advanced success/failure logic

Spring Data JDBC Tutorial

Sadiul Hakim — Sat, 01 Nov 2025 14:15:45 +0000

1. What is Spring Data JDBC?

Spring Data JDBC is a persistence framework that provides a simplified approach to working with relational databases using JDBC. It offers:

Repository abstraction - Reduces boilerplate code
Object mapping - Maps Java objects to database tables
Simple configuration - Minimal setup required
No caching/lazy loading - Predictable database access
DDL generation - Can automatically create database schema

Unlike JPA/Hibernate, Spring Data JDBC doesn't include:

Session/caching complexity
Lazy loading
Dirty checking
Complex mapping configurations

2. When to Use Spring Data JDBC?

Use Spring Data JDBC when:

You want simple, predictable SQL access
You prefer explicit database operations
You need direct control over SQL queries
Your domain model aligns well with database schema
You want to avoid JPA complexity

Consider JPA/Hibernate when:

You need complex object relationships
You want automatic dirty checking
Caching is important
You have complex inheritance hierarchies

3. Basic Concepts

Key Components:

Entities - Java classes mapped to database tables
Repositories - Interfaces for CRUD operations
Aggregate Roots - Main entities that are persisted
Embedded Types - Value objects stored within entities

Dependencies (Maven)

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jdbc</artifactId>
</dependency>
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
</dependency>

4. CRUD Examples

Entity Definition

import org.springframework.data.annotation.Id;
import org.springframework.data.relational.core.mapping.Table;
import java.time.LocalDateTime;

@Table("users")
public class User {
    @Id
    private Long id;
    private String username;
    private String email;
    private LocalDateTime createdAt;

    // Constructors
    public User() {}

    public User(String username, String email) {
        this.username = username;
        this.email = email;
        this.createdAt = LocalDateTime.now();
    }

    // Getters and Setters
    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; }

    public LocalDateTime getCreatedAt() { return createdAt; }
    public void setCreatedAt(LocalDateTime createdAt) { this.createdAt = createdAt; }
}

Repository Interface

import org.springframework.data.jdbc.repository.query.Query;
import org.springframework.data.repository.CrudRepository;
import org.springframework.data.repository.query.Param;
import java.util.List;
import java.util.Optional;

public interface UserRepository extends CrudRepository<User, Long> {

    // Custom query methods
    Optional<User> findByUsername(String username);
    List<User> findByEmailContaining(String emailPart);

    // Custom SQL query
    @Query("SELECT * FROM users WHERE created_at >= :since")
    List<User> findUsersCreatedAfter(@Param("since") LocalDateTime since);

    // Count method
    long countByEmailEndingWith(String domain);
}

Service Class

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Optional;

@Service
public class UserService {

    private final UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    // CREATE - Save new user
    public User createUser(User user) {
        return userRepository.save(user);
    }

    // READ - Get user by ID
    public Optional<User> getUserById(Long id) {
        return userRepository.findById(id);
    }

    // READ - Get all users
    public Iterable<User> getAllUsers() {
        return userRepository.findAll();
    }

    // READ - Custom query
    public List<User> getUsersByEmailDomain(String domain) {
        return userRepository.findByEmailContaining(domain);
    }

    // UPDATE - Update user
    public User updateUser(User user) {
        if (user.getId() == null) {
            throw new IllegalArgumentException("User ID cannot be null for update");
        }
        return userRepository.save(user);
    }

    // DELETE - Delete user by ID
    public void deleteUser(Long id) {
        userRepository.deleteById(id);
    }

    // Complex operation with transaction
    @Transactional
    public void updateUserEmail(Long userId, String newEmail) {
        User user = userRepository.findById(userId)
            .orElseThrow(() -> new RuntimeException("User not found"));
        user.setEmail(newEmail);
        userRepository.save(user);
    }
}

Configuration

import org.springframework.context.annotation.Configuration;
import org.springframework.data.jdbc.repository.config.EnableJdbcRepositories;

@Configuration
@EnableJdbcRepositories
public class DataConfig {
    // Configuration is automatically handled by Spring Boot
}

application.properties

# H2 Database Configuration
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=

# H2 Console (for testing)
spring.h2.console.enabled=true

# Show SQL queries
spring.data.jdbc.repositories.log-sql-queries=true

# Auto-create schema
spring.sql.init.mode=always

Schema SQL (src/main/resources/schema.sql)

CREATE TABLE IF NOT EXISTS users (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    username VARCHAR(255) NOT NULL UNIQUE,
    email VARCHAR(255) NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

Test Data (src/main/resources/data.sql)

INSERT INTO users (username, email) VALUES 
('john_doe', 'john@example.com'),
('jane_smith', 'jane@example.com'),
('bob_wilson', 'bob@example.com');

Controller Example

import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import java.util.List;
import java.util.Optional;

@RestController
@RequestMapping("/api/users")
public class UserController {

    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @PostMapping
    public ResponseEntity<User> createUser(@RequestBody User user) {
        User savedUser = userService.createUser(user);
        return ResponseEntity.ok(savedUser);
    }

    @GetMapping("/{id}")
    public ResponseEntity<User> getUser(@PathVariable Long id) {
        Optional<User> user = userService.getUserById(id);
        return user.map(ResponseEntity::ok)
                  .orElse(ResponseEntity.notFound().build());
    }

    @GetMapping
    public List<User> getAllUsers() {
        return (List<User>) userService.getAllUsers();
    }

    @PutMapping("/{id}")
    public ResponseEntity<User> updateUser(@PathVariable Long id, @RequestBody User user) {
        user.setId(id);
        User updatedUser = userService.updateUser(user);
        return ResponseEntity.ok(updatedUser);
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
        userService.deleteUser(id);
        return ResponseEntity.noContent().build();
    }
}

Testing the Implementation

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.Optional;
import static org.junit.jupiter.api.Assertions.*;

@SpringBootTest
class UserServiceTest {

    @Autowired
    private UserService userService;

    @Test
    void testCreateAndFindUser() {
        // Create
        User user = new User("testuser", "test@example.com");
        User savedUser = userService.createUser(user);

        assertNotNull(savedUser.getId());

        // Read
        Optional<User> foundUser = userService.getUserById(savedUser.getId());
        assertTrue(foundUser.isPresent());
        assertEquals("testuser", foundUser.get().getUsername());
    }

    @Test
    void testUpdateUser() {
        User user = new User("updateuser", "update@example.com");
        User savedUser = userService.createUser(user);

        savedUser.setEmail("updated@example.com");
        User updatedUser = userService.updateUser(savedUser);

        assertEquals("updated@example.com", updatedUser.getEmail());
    }

    @Test
    void testDeleteUser() {
        User user = new User("deleteuser", "delete@example.com");
        User savedUser = userService.createUser(user);

        userService.deleteUser(savedUser.getId());

        Optional<User> deletedUser = userService.getUserById(savedUser.getId());
        assertFalse(deletedUser.isPresent());
    }
}

Main Application Class

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SpringDataJdbcApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringDataJdbcApplication.class, args);
    }
}

Key Points to Remember:

Simple Mapping: Fields are mapped directly to columns by name
No Proxies: Objects are always real instances, no lazy loading
Explicit Operations: Everything is explicit - no automatic dirty checking
Aggregate Roots: Focus on persisting complete aggregates
Transaction Management: Use @Transactional for multi-operation transactions

Spring Boot Properties: Complete Tutorial

Sadiul Hakim — Thu, 30 Oct 2025 09:56:59 +0000

1. What are Spring Boot Properties?

Spring Boot properties are configuration settings that control the behavior of your Spring Boot application. They allow you to externalize configuration and work with the same application code in different environments.

Types of Properties:

Application Properties: Basic application configuration
Profile-specific Properties: Environment-specific configurations
Third-party Properties: Configuration for integrated libraries and frameworks

2. Why Use Properties and When?

Benefits:

Externalized Configuration: Separate configuration from code
Environment-specific Settings: Different configurations for dev, test, prod
No Code Changes: Modify behavior without recompiling
Type Safety: Strongly bound to configuration classes
Auto-completion: IDE support for property names

When to Use:

Database connections
Server configuration
Feature toggles
External service URLs
Security settings
Logging levels
Performance tuning

3. Ways of Using Properties

3.1 Property Files Location (Order of Precedence)

# 1. Dev tools global settings (.spring-boot-devtools.properties)
# 2. @TestPropertySource on tests
# 3. @SpringBootTest properties
# 4. Command line arguments
# 5. SPRING_APPLICATION_JSON (inline JSON embedded in env variable)
# 6. ServletConfig init parameters
# 7. ServletContext init parameters
# 8. java:comp/env JNDI attributes
# 9. System.getProperties()
# 10. OS environment variables
# 11. RandomValuePropertySource (random.*)
# 12. Profile-specific application-{profile}.properties
# 13. Application properties (application.properties)
# 14. @PropertySource on @Configuration classes
# 15. Default properties (SpringApplication.setDefaultProperties)

3.2 Property Files Format

application.properties:

# Basic properties
server.port=8080
spring.application.name=myapp

# Database
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=user
spring.datasource.password=pass

# Lists and arrays
spring.profiles.active=dev,test
myapp.servers[0]=server1
myapp.servers[1]=server2

application.yml:

# YAML format (alternative)
server:
  port: 8080
spring:
  application:
    name: myapp
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: user
    password: pass
myapp:
  servers:
    - server1
    - server2

3.3 Accessing Properties in Code

Using @Value:

@Component
public class MyComponent {

    @Value("${server.port}")
    private int serverPort;

    @Value("${myapp.feature.enabled:false}") // default value
    private boolean featureEnabled;

    @Value("${myapp.servers}")
    private List<String> servers;
}

Using @ConfigurationProperties:

@Configuration
@ConfigurationProperties(prefix = "app.config")
public class AppConfig {
    private String name;
    private List<String> servers = new ArrayList<>();
    private Database database = new Database();

    // getters and setters
    public static class Database {
        private String host;
        private int port;
        // getters and setters
    }
}

application.properties:

app.config.name=MyApplication
app.config.servers[0]=server1
app.config.servers[1]=server2
app.config.database.host=localhost
app.config.database.port=3306

3.4 Profile-specific Properties

application-dev.properties:

spring.datasource.url=jdbc:h2:mem:testdb
spring.h2.console.enabled=true
logging.level.com.myapp=DEBUG

application-prod.properties:

spring.datasource.url=jdbc:mysql://prod-db:3306/mydb
logging.level.com.myapp=INFO
management.endpoints.web.exposure.include=health,info

3.5 Conditional Configuration

@Configuration
@ConditionalOnProperty(name = "app.feature.cache.enabled", havingValue = "true")
public class CacheConfig {
    // This configuration only loads if property is set to true
}

4. Common Properties by Category

4.1 Core Spring Properties

# Application basic config
spring.application.name=my-service
spring.profiles.active=dev
spring.main.banner-mode=console
spring.main.lazy-initialization=true

# Internationalization
spring.messages.basename=messages
spring.web.locale=en_US

# File upload
spring.servlet.multipart.max-file-size=10MB
spring.servlet.multipart.max-request-size=10MB

4.2 Database Properties (JDBC)

# DataSource
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=dbuser
spring.datasource.password=dbpass
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# Connection pool (HikariCP)
spring.datasource.hikari.connection-timeout=30000
spring.datasource.hikari.maximum-pool-size=20
spring.datasource.hikari.minimum-idle=5

# Embedded database
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driver-class-name=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.h2.console.enabled=true

4.3 JPA/Hibernate Properties

# JPA
spring.jpa.database-platform=org.hibernate.dialect.MySQL8Dialect
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true
spring.jpa.hibernate.ddl-auto=update
spring.jpa.open-in-view=false

# Hibernate specific
spring.jpa.properties.hibernate.jdbc.batch_size=20
spring.jpa.properties.hibernate.order_inserts=true
spring.jpa.properties.hibernate.order_updates=true
spring.jpa.properties.hibernate.query.fail_on_pagination_over_collection_fetch=true

# Second-level cache
spring.jpa.properties.hibernate.cache.use_second_level_cache=true
spring.jpa.properties.hibernate.cache.region.factory_class=org.hibernate.cache.jcache.JCacheRegionFactory
spring.jpa.properties.javax.persistence.sharedCache.mode=ALL

4.4 Web/Server Properties

# Server configuration
server.port=8080
server.servlet.context-path=/api
server.servlet.session.timeout=30m
server.compression.enabled=true
server.compression.mime-types=text/html,text/xml,text/plain,text/css,text/javascript,application/javascript,application/json
server.compression.min-response-size=1024

# Tomcat specific
server.tomcat.max-threads=200
server.tomcat.max-connections=10000
server.tomcat.accept-count=100
server.tomcat.accesslog.enabled=true
server.tomcat.accesslog.pattern=%t %a "%r" %s (%D ms)

# SSL
server.ssl.key-store=classpath:keystore.p12
server.ssl.key-store-password=secret
server.ssl.key-store-type=PKCS12
server.ssl.key-alias=tomcat

4.5 Security Properties

# Basic Security
spring.security.user.name=admin
spring.security.user.password=secret
spring.security.user.roles=ADMIN,USER

# OAuth2
spring.security.oauth2.client.registration.my-client.client-id=client-id
spring.security.oauth2.client.registration.my-client.client-secret=client-secret
spring.security.oauth2.client.registration.my-client.scope=read,write
spring.security.oauth2.client.registration.my-client.authorization-grant-type=authorization_code
spring.security.oauth2.client.registration.my-client.redirect-uri=http://localhost:8080/login/oauth2/code/my-client

# JWT
app.security.jwt.secret=mySecretKey
app.security.jwt.expiration=86400000

4.6 Logging Properties

# Logging levels
logging.level.com.myapp=DEBUG
logging.level.org.springframework.web=INFO
logging.level.org.hibernate=WARN

# Log file
logging.file.name=app.log
logging.file.path=/var/log
logging.pattern.console=%d{yyyy-MM-dd HH:mm:ss} - %msg%n
logging.pattern.file=%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n

# Logback specific
logging.logback.rollingpolicy.max-file-size=10MB
logging.logback.rollingpolicy.max-history=30

4.7 Mail Properties

# SMTP configuration
spring.mail.host=smtp.gmail.com
spring.mail.port=587
spring.mail.username=user@gmail.com
spring.mail.password=app-password
spring.mail.properties.mail.smtp.auth=true
spring.mail.properties.mail.smtp.starttls.enable=true
spring.mail.properties.mail.smtp.starttls.required=true

# Mail sender
spring.mail.default-encoding=UTF-8
spring.mail.protocol=smtp
spring.mail.test-connection=false

4.8 Cache Properties

# Cache auto-configuration
spring.cache.type=redis
spring.cache.redis.time-to-live=600000
spring.cache.redis.cache-null-values=true
spring.cache.redis.key-prefix=cache:

# Redis specific
spring.redis.host=localhost
spring.redis.port=6379
spring.redis.password=
spring.redis.database=0
spring.redis.timeout=2000

# Caffeine cache
spring.cache.caffeine.spec=maximumSize=500,expireAfterAccess=600s

4.9 Actuator Properties

# Actuator endpoints
management.endpoints.web.exposure.include=health,info,metrics,env
management.endpoints.web.exposure.exclude=shutdown
management.endpoint.health.show-details=always
management.endpoint.health.show-components=always

# Health indicators
management.health.db.enabled=true
management.health.redis.enabled=true
management.health.diskspace.enabled=true

# Custom info
management.info.env.enabled=true
management.info.build.enabled=true
management.info.git.enabled=true

# Metrics
management.metrics.export.prometheus.enabled=true
management.metrics.distribution.percentiles-histogram.http.server.requests=true

4.10 Thymeleaf Properties

# Thymeleaf template engine
spring.thymeleaf.prefix=classpath:/templates/
spring.thymeleaf.suffix=.html
spring.thymeleaf.mode=HTML
spring.thymeleaf.encoding=UTF-8
spring.thymeleaf.servlet.content-type=text/html
spring.thymeleaf.cache=false # Set to true in production
spring.thymeleaf.check-template-location=true

4.11 WebSocket Properties

# WebSocket configuration
spring.websocket.servlet.max-session-idle-timeout=300000
spring.websocket.servlet.max-text-message-buffer-size=8192
spring.websocket.servlet.max-binary-message-buffer-size=8192

# STOMP broker
spring.websocket.stomp.relay.host=localhost
spring.websocket.stomp.relay.port=61613
spring.websocket.stomp.broker.relay.enabled=true

4.12 Batch Properties

# Spring Batch
spring.batch.job.enabled=false
spring.batch.job.name=myJob
spring.batch.initialize-schema=always
spring.batch.table-prefix=BATCH_

# Job repository
spring.batch.jdbc.initialize-schema=always
spring.batch.job.repository.isolation-level-for-create=default

4.13 Cloud Properties

# Spring Cloud Config
spring.cloud.config.uri=http://localhost:8888
spring.cloud.config.name=myapp
spring.cloud.config.profile=dev
spring.cloud.config.label=main

# Eureka Client
eureka.client.service-url.defaultZone=http://localhost:8761/eureka/
eureka.instance.prefer-ip-address=true
eureka.instance.instance-id=${spring.cloud.client.ip-address}:${server.port}

# Circuit Breaker
resilience4j.circuitbreaker.instances.backend.failure-rate-threshold=50
resilience4j.circuitbreaker.instances.backend.wait-duration-in-open-state=10s

4.14 Compression Properties

# Response compression
server.compression.enabled=true
server.compression.mime-types=text/html,text/xml,text/plain,text/css,text/javascript,application/javascript,application/json,application/xml
server.compression.min-response-size=1024

# Gzip compression for static content
spring.resources.chain.gzipped=true
spring.resources.chain.strategy.content.enabled=true
spring.resources.chain.strategy.content.paths=/**

5. Advanced Usage Examples

5.1 Custom Configuration Properties

@Configuration
@ConfigurationProperties(prefix = "app")
@Validated
public class AppProperties {

    @NotBlank
    private String name;

    @Min(1)
    private int maxConnections;

    private List<String> allowedHosts;

    private Security security = new Security();

    // getters and setters

    public static class Security {
        private boolean enabled;
        private String secretKey;
        private long tokenValidity;

        // getters and setters
    }
}

5.2 Profile-based Configuration

@Configuration
@Profile("dev")
public class DevConfig {
    // Development specific beans
}

@Configuration
@Profile("prod")
public class ProdConfig {
    // Production specific beans
}

5.3 Property Validation

@ConfigurationProperties(prefix = "app")
@Validated
public class AppProperties {

    @NotNull
    @URL
    private String serverUrl;

    @Min(1)
    @Max(65535)
    private int serverPort;

    @Pattern(regexp = "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,6}$")
    private String adminEmail;
}

5.4 Dynamic Property Refresh

@RefreshScope
@Component
public class MyRefreshedComponent {

    @Value("${app.dynamic.config}")
    private String dynamicConfig;

    // This value will be refreshed when /actuator/refresh is called
}

6. Best Practices

Use YAML for complex hierarchical configurations
Externalize environment-specific properties
Use sensible default values
Validate configuration properties
Use profile-specific properties for different environments
Keep sensitive data in secure property sources
Use @ConfigurationProperties for type-safe configuration
Document your custom properties

Maven Plugins

Sadiul Hakim — Mon, 27 Oct 2025 04:56:25 +0000

What is a Maven Plugin?

A Maven plugin is a set of goals that extend Maven’s functionality.
Think of Maven as the engine, and plugins as tools that tell Maven what to do — like compiling code, packaging a JAR, running tests, or deploying to a server.

Each plugin performs a specific task in the build lifecycle.

Example:

maven-compiler-plugin → compiles Java source files.

maven-surefire-plugin → runs unit tests.

maven-jar-plugin → packages compiled code into a JAR file.

How Plugins Work

A Maven build lifecycle (e.g., clean, default, site) consists of phases like compile, test, package, install, and deploy.

Each phase executes one or more plugin goals.

Example:

mvn package

runs:

compile → via maven-compiler-plugin
test → via maven-surefire-plugin
package → via maven-jar-plugin (or maven-war-plugin)

Why Use Plugins?

Because Maven itself doesn’t "do" much — it delegates all real work to plugins.

They let you:

Automate build steps (compile, test, package)
Run code quality checks
Generate reports
Deploy artifacts to a repository
Create Docker images, run servers, etc.

Basically, plugins = automation + flexibility.

When to Use Plugins

Use a plugin when you need Maven to perform a custom or automated task that’s not built-in.
Examples:

Situation	Plugin
Need to compile Java code	`maven-compiler-plugin`
Need to create a JAR/WAR	`maven-jar-plugin` / `maven-war-plugin`
Need to run unit tests	`maven-surefire-plugin`
Need to run integration tests	`maven-failsafe-plugin`
Need to execute custom Java class	`exec-maven-plugin`
Need to package app as Docker image	`jib-maven-plugin` or `spotify-dockerfile-maven-plugin`
Need to format code or lint	`spotless-maven-plugin`, `checkstyle-maven-plugin`

Common Maven Plugins (with Use Cases)

Plugin	Goal / Phase	Purpose
maven-compiler-plugin	`compile`, `test-compile`	Compiles Java source code and test code.
maven-surefire-plugin	`test`	Runs unit tests.
maven-failsafe-plugin	`integration-test`, `verify`	Runs integration tests (after packaging).
maven-jar-plugin	`package`	Builds `.jar` files.
maven-war-plugin	`package`	Builds `.war` files for web apps.
maven-install-plugin	`install`	Installs the package into the local repository (`~/.m2/repository`).
maven-deploy-plugin	`deploy`	Deploys artifacts to remote repositories.
maven-clean-plugin	`clean`	Deletes `target/` directory before a new build.
maven-site-plugin	`site`	Generates project documentation.
exec-maven-plugin	Custom goals	Runs Java main classes or external commands.
spring-boot-maven-plugin	`repackage`	Packages Spring Boot apps as executable JARs, allows `mvn spring-boot:run`.
checkstyle-maven-plugin	`verify`	Performs static code analysis using Checkstyle rules.
spotless-maven-plugin	`verify`	Formats and enforces code style.
jib-maven-plugin	Custom goal	Builds Docker/OCI images without Dockerfile.
liquibase-maven-plugin	Custom goal	Runs database migrations with Liquibase.

Example: Define a Plugin in `pom.xml`

<build>
  <plugins>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-compiler-plugin</artifactId>
      <version>3.11.0</version>
      <configuration>
        <source>21</source>
        <target>21</target>
      </configuration>
    </plugin>
  </plugins>
</build>

Now running:

mvn compile

will use Java 21 for compilation.

Summary

Concept	Description
What	Plugins extend Maven’s capabilities via goals.
How	Bound to build phases (like compile/test/package).
Why	Automate builds, testing, deployment, quality checks.
When	Whenever a project step can be automated or repeated.

SPRING CORE COMPLETE TUTORIAL

Sadiul Hakim — Wed, 22 Oct 2025 11:40:28 +0000

1. Introduction to Spring Framework

What is Spring?

Spring is a Java framework that helps you build powerful, testable, and maintainable applications easily.
It manages your application’s objects (beans) — how they are created, connected, and destroyed.

Why use Spring?

Reduces boilerplate code.
Makes applications loosely coupled.
Supports modular design.
Provides integration with other frameworks (Hibernate, JPA, etc.).
Easy to test.

Inversion of Control (IoC)

Instead of you creating objects manually using new, Spring Container creates and manages them for you.

Without Spring:

UserService service = new UserService(new UserRepository());

With Spring:

@Autowired
UserService service;

Spring automatically creates and injects the UserService and its dependencies.

Dependency Injection (DI)

It’s the process of injecting dependent objects into a class rather than creating them inside the class.

2. Spring IoC Container

The container is the brain of Spring. It creates and manages beans.

There are two main containers:

BeanFactory → Basic, lazy-loading.
ApplicationContext → Advanced, supports events, AOP, etc.

Example 1: XML Configuration

beans.xml

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="greetingService" class="com.example.GreetingService"/>
</beans>

Main.java

ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
GreetingService service = context.getBean("greetingService", GreetingService.class);
service.sayHello();

Example 2: Java Configuration

AppConfig.java

@Configuration
public class AppConfig {
    @Bean
    public GreetingService greetingService() {
        return new GreetingService();
    }
}

Main.java

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
GreetingService service = context.getBean(GreetingService.class);
service.sayHello();

3. Spring Beans

A bean is just an object managed by the Spring container.

Example

@Component
public class GreetingService {
    public void sayHello() {
        System.out.println("Hello, Spring!");
    }
}

Bean Scopes

Scope	Description
`singleton`	One shared instance (default)
`prototype`	New instance each time
`request`	One per HTTP request
`session`	One per HTTP session

@Scope("prototype")
@Component
public class ReportGenerator { }

Bean Lifecycle

Bean instantiated
Dependencies injected
@PostConstruct → called after init
@PreDestroy → called before destroy

@Component
public class DemoBean {
    @PostConstruct
    void init() { System.out.println("Bean initialized!"); }

    @PreDestroy
    void destroy() { System.out.println("Bean destroyed!"); }
}

4. Dependency Injection (DI)

1️Constructor Injection

@Component
public class Car {
    private final Engine engine;

    @Autowired
    public Car(Engine engine) {
        this.engine = engine;
    }
}

Setter Injection

@Component
public class Car {
    private Engine engine;

    @Autowired
    public void setEngine(Engine engine) {
        this.engine = engine;
    }
}

Field Injection

@Autowired
private Engine engine;

Not recommended for testing — constructor is preferred.

`@Qualifier` and `@Primary`

When multiple beans of same type exist:

@Component("v8")
public class V8Engine implements Engine {}

@Component("v6")
@Primary
public class V6Engine implements Engine {}

Now Car gets V6Engine by default.

5. Spring Configuration

External Configuration (properties file)

application.properties

app.name=MySpringApp

Java Config

@Value("${app.name}")
private String appName;

Profiles

You can create environment-specific beans.

@Profile("dev")
@Bean
public DataSource devDataSource() { ... }

@Profile("prod")
@Bean
public DataSource prodDataSource() { ... }

Activate with:

-Dspring.profiles.active=dev

6. Spring Expression Language (SpEL)

You can inject values dynamically using expressions.

@Component
public class MathBean {

    @Value("#{5 + 10}")
    private int sum;  // 15

    @Value("#{T(java.lang.Math).random() * 100}")
    private double randomValue;
}

You can also reference other beans:

@Value("#{greetingService.sayHello()}")
private String message;

7. Spring AOP (Aspect-Oriented Programming)

Used to separate cross-cutting concerns (like logging, security, transactions).

Example

@Aspect
@Component
public class LoggingAspect {

    @Before("execution(* com.example.service.*.*(..))")
    public void logBefore(JoinPoint jp) {
        System.out.println("Method called: " + jp.getSignature());
    }
}

Main Config

@EnableAspectJAutoProxy
@Configuration
@ComponentScan("com.example")
public class AppConfig { }

Now, whenever a method in com.example.service runs, the aspect prints a log automatically.

8. Event Handling

Spring supports application events (publish-subscribe model).

@Component
public class MyEventListener {

    @EventListener
    public void handleEvent(ContextRefreshedEvent event) {
        System.out.println("Context initialized!");
    }
}

You can also publish custom events:

public class UserCreatedEvent extends ApplicationEvent {
    public UserCreatedEvent(Object source) { super(source); }
}

@Component
public class EventPublisher {
    @Autowired private ApplicationEventPublisher publisher;

    public void publishEvent() {
        publisher.publishEvent(new UserCreatedEvent(this));
    }
}

9. Common Spring Annotations

Annotation	Description
`@Configuration`	Declares a configuration class
`@Bean`	Defines a bean method
`@ComponentScan`	Scans for components
`@Component`	Marks a general bean
`@Service`	Marks a service-layer bean
`@Repository`	Marks a DAO-layer bean
`@Controller`	Marks a controller-layer bean
`@Autowired`	Injects dependency
`@Qualifier`	Chooses specific bean
`@Primary`	Marks preferred bean
`@Scope`	Defines bean scope
`@Value`	Injects property value
`@Profile`	Environment-specific beans

10. Spring Boot Core Add-ons

Spring Boot builds on top of Spring Core, simplifying configuration.

Example

@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

Automatically scans components
Handles configuration automatically
External config via application.yml or .properties
Includes embedded Tomcat

Summary

Topic	Key Idea
1. Intro	Spring manages your objects
2. IoC	Container creates & injects beans
3. Beans	Managed objects with lifecycle
4. DI	Inject dependencies, not `new` them
5. Config	Java, XML, or properties-based setup
6. SpEL	Dynamic expressions in annotations
7. AOP	Separate cross-cutting concerns
8. Events	Publish and listen for events
9. Annotations	Declarative setup for everything
10. Boot Add-ons	Auto configuration & simplicity

DEV Community: Sadiul Hakim

PHP Laravel Artisan Custom Command

What is Laravel Artisan?

Why create custom Artisan commands?

Creating a Custom Command

Anatomy of a Command

Command Signature (Arguments & Options)

Basic argument

Optional argument

Option (flags)

Taking Text Input (Interactive)

Ask for input

Ask with default

Ask secretly (passwords)

Confirm (Yes / No)

Multiple Choice (Single Select)

Output Helpers (Very Important)

Full Sample Command (REALISTIC)

Create it

Code: app/Console/Commands/CreateUserCli.php

Run it

Exit Codes (Pro Tip)

Where Commands Are Registered?

Common Real-World Uses

DFS and BFS algorithm in php

1. Problem Setup (Tree Structure)

Tree Visualization

2. BFS (Breadth First Search)

What BFS Means

BFS Algorithm (Concept)

BFS Code (Your Example, Explained)

BFS Execution Order (Step by Step)

BFS Output

When to Use BFS

3. DFS (Depth First Search)

What DFS Means

DFS Algorithm (Iterative)

DFS Code Using SplStack

DFS Execution Order (Step by Step)

DFS Output

When to Use DFS

4. DFS Using Recursion (Classic)

Why Stack Version Is Better in PHP

5. BFS vs DFS (Quick Comparison)

6. Key Takeaways

PHP SPL: Stack and Queue Tutorial

1. What is SPL?

2. Stack vs Queue (Concept)

Stack (LIFO)

Queue (FIFO)

3. SplStack

3.1 Creating a Stack

3.2 Pushing Elements (push)

3.3 Popping Elements (pop)

3.4 Peeking Top Element (top)

3.5 Checking if Stack is Empty

3.6 Counting Elements

3.7 Iterating a Stack

3.8 Real-World Example: Undo Feature

4. SplQueue

4.1 Creating a Queue

4.2 Enqueue (add to queue)

4.3 Dequeue (remove from queue)

4.4 Peeking Front Element

4.5 Checking if Queue is Empty

4.6 Counting Elements

4.7 Iterating a Queue

4.8 Real-World Example: Job Processing

5. Stack vs Queue Summary

6. Common Mistakes

❌ Using arrays instead of SPL

❌ Confusing top() and bottom() in Queue

7. When to Use SPL in Laravel / PHP Apps

8. Performance Note

9. Quick Cheat Sheet

Laravel Artisan Commands – Practical Tutorial

1. Controller Commands

1.1 Basic Controller

1.2 Resource Controller

1.3 API Resource Controller

Code: `app/Console/Commands/CreateUserCli.php`

DFS Code Using `SplStack`