DEV Community: Abdelmajid E.

Design Pattern : difference between composition and inheritance and decorator.

Abdelmajid E. — Fri, 04 Oct 2024 13:25:07 +0000

To Understand the difference between these three design pattern, first we need to understand each one of them:

Inheritance

What is Inheritance?

Inheritance is one of the object-oriented programming concepts in Java. Inheritance enables the acquisition of data members and properties from one class to another.

Base Class (Parent Class)
The base class provides the data members and methods in alternative words. Any base class that needs methods or data members will have to borrow them from their respective parent or base class.
Subclass (Child Class)
The subclass is also known as the child class. The implementation of its parent class recreates a new class, which is the child class.

To inherit the parent class, a child class must include a keyword called "extends." The keyword "extends" enables the compiler to understand that the child class derives the functionalities and members of its parent class.

Why Do We Need Inheritance?

We need use Inheritance for two main reason:

Run-Time Polymorphism
Runtime, also known as dynamic polymorphism, is a method call in the execution process that overrides a different method in the run time.
Code Reusability
The process of inheritance involves reusing the methods and data members defined in the parent class. Inheritance eliminates the need to write the same code in the child class—saving time as a result.

Example here is the class diagram:

The code:

package org.designpattern;

public class Main {
    public static void main(String[] args) {
        // Create an array of Shape objects
        Shape[] shapes = new Shape[3];
        shapes[0] = new Circle("Red", 5);
        shapes[1] = new Rectangle("Blue", 4, 6);
        shapes[2] = new Circle("Green", 3);

        // Iterate through the shapes and demonstrate polymorphism
        for (Shape shape : shapes) {
            shape.displayColor();
            System.out.println("Area: " + shape.calculateArea());

            // Demonstrate instanceof and casting
            if (shape instanceof Circle) {
                System.out.println("This is a circle");
            } else if (shape instanceof Rectangle) {
                System.out.println("This is a rectangle");
            }

            System.out.println(); // For readability
        }
    }
}

/** Parent class
 * this class should have at least one abstract method (in this cas it is calculateArea())
 **/
abstract class Shape {
    protected String color;

    public Shape(String color) {
        this.color = color;
    }

    // abstract method
    public abstract double calculateArea();

    public void displayColor() {
        System.out.println("This shape is " + color);
    }
}

// Child class Circle
class Circle extends Shape {
    private double radius;

    public Circle(String color, double radius) {
        super(color);
        this.radius = radius;
    }

    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
}

// Child class Rectangle
class Rectangle extends Shape {
    private double length;
    private double width;

    public Rectangle(String color, double length, double width) {
        super(color);
        this.length = length;
        this.width = width;
    }

    @Override
    public double calculateArea() {
        return length * width;
    }
}

We have a class abstract which is the parent (in another base class) (NB: this class should have at least one method abstract).

What is composition

Composition in java is the design technique to implement has-a relationship in classes. We can use java inheritance or Object composition in java for code reuse.
Java composition is achieved by using instance variables that refers to other objects. For example, a House has a Room. Let’s see this with a java composition example code.

import java.util.ArrayList;
import java.util.List;

class House {
    private List<Room> rooms;

    public House() {
        this.rooms = new ArrayList<>();
    }

    public void addRoom(String name, long width, long length, long height) {
        Room room = new Room(name, width, length, height);
        rooms.add(room);
    }

    public List<Room> getRooms() {
        return rooms;
    }

    public void printHouseDetails() {
        for (Room room : rooms) {
            System.out.println("Room: " + room.getName());
            System.out.println("Dimensions (WxLxH): " + room.getWidth() + " x " + room.getLength() + " x " + room.getHeight());
            System.out.println();
        }
    }

}

class Room {
    private String name;
    private long width;
    private long length;
    private long height;

    public Room(String name, long width, long length, long height) {
        this.name = name;
        this.width = width;
        this.length = length;
        this.height = height;
    }

    public String getName() {
        return name;
    }

    public long getWidth() {
        return width;
    }

    public long getLength() {
        return length;
    }

    public long getHeight() {
        return height;
    }

}

public class Composition {
    public static void main(String[] args) {
        House house = new House();
        house.addRoom("Living Room", 500, 600, 300);
        house.addRoom("Bedroom", 400, 500, 300);
        house.addRoom("Kitchen", 300, 400, 300);

        house.printHouseDetails();
    }
}

Why do we need Composition

Notice that above test program for composition in java is not affected by any change in the Room object. If you are looking for code reuse and the relationship between two classes is has-a then you should use composition rather than inheritance. Benefit of using composition in java is that we can control the visibility of other object to client classes and reuse only what we need. Also if there is any change in the other class implementation, for example getRooms returning list of Room, we need to change House class to accommodate it but client classes doesn’t need to change. Composition allows creation of back-end class when it’s needed.

types of composition:

One to One:
In a one-to-one composition, one object is composed of exactly one instance of another object. This implies a strong relationship where the composed object is a crucial part of the composing object.

Example: A Person and their Heart. Each person has exactly one heart, and the heart cannot exist independently of the person.

class Person {
    private Heart heart;

    public Person() {
        this.heart = new Heart();
    }

    // getters and other methods
}

class Heart {
    // Heart properties and methods
}

One to Many:
In a one-to-many composition, one object is composed of multiple instances of another object. The composed objects are part of the lifecycle of the composing object.

Example: A Library and Books. A library contains many books, but those books are part of the library's collection.

import java.util.ArrayList;
import java.util.List;

class Library {
    private List<Book> books;

    public Library() {
        this.books = new ArrayList<>();
    }

    public void addBook(Book book) {
        books.add(book);
    }

    // getters and other methods
}

class Book {
    private String title;

    public Book(String title) {
        this.title = title;
    }

    // getters and other methods
}

Many to One:
In a many-to-one composition, multiple objects are composed within one instance of another object. This often implies that the composed object has a shared dependency on a single instance of the other object.

Example: Several Employees working in a single Company. Each employee works for one company, and the company manages all its employees.

import java.util.ArrayList;
import java.util.List;

class Company {
    private List<Employee> employees;

    public Company() {
        this.employees = new ArrayList<>();
    }

    public void addEmployee(Employee employee) {
        employees.add(employee);
    }

    // getters and other methods
}

class Employee {
    private String name;

    public Employee(String name) {
        this.name = name;
    }

    // getters and other methods
}

What is decorator

The decorator design pattern allows us to dynamically add functionality and behavior to an object without affecting the behavior of other existing objects in the same class.

We use inheritance or composition to extend the behavior of an object but this is done at compile time and its applicable to all the instances of the class. We can’t add any new functionality of remove any existing behavior at runtime - this is when Decorator pattern comes into picture. Suppose we want to implement different kinds of cars - we can create interface Car to define the assemble method and then we can have a Basic car, further more we can extend it to Sports car and Luxury Car. The implementation hierarchy will look like below image.

// Step 1: Define the Car interface
interface Car {
    void assemble();
}

// Step 2: Create a basic implementation of Car
class BasicCar implements Car {
    @Override
    public void assemble() {
        System.out.print("Basic Car.");
    }
}

// Step 3: Create the CarDecorator class implementing the Car interface
class CarDecorator implements Car {
    protected Car car;

    public CarDecorator(Car car) {
        this.car = car;
    }

    @Override
    public void assemble() {
        this.car.assemble();  // Delegates the call to the wrapped car object
    }
}

// Step 4: Create specific decorators by extending CarDecorator
class SportsCar extends CarDecorator {

    public SportsCar(Car car) {
        super(car);
    }

    @Override
    public void assemble() {
        super.assemble();
        System.out.print(" Adding features of a Sports Car.");
    }
}

class LuxuryCar extends CarDecorator {

    public LuxuryCar(Car car) {
        super(car);
    }

    @Override
    public void assemble() {
        super.assemble();
        System.out.print(" Adding features of a Luxury Car.");
    }
}

// Step 5: Demonstrate the usage of the Decorator Pattern
public class DecoratorPatternTest {
    public static void main(String[] args) {
        Car sportsCar = new SportsCar(new BasicCar());
        sportsCar.assemble();
        System.out.println("\n-----");

        Car luxuryCar = new LuxuryCar(new BasicCar());
        luxuryCar.assemble();
        System.out.println("\n-----");

        Car sportsLuxuryCar = new SportsCar(new LuxuryCar(new BasicCar()));
        sportsLuxuryCar.assemble();
    }
}

output

Basic Car. Adding features of a Sports Car.
Basic Car. Adding features of a Luxury Car.
Basic Car. Adding features of a Luxury Car. Adding features of a Sports Car.

Conclusion:

To understand the differences between inheritance, composition, and decorator design patterns, it’s important to grasp each concept individually:

Inheritance is used for an "is-a" relationship where classes inherit methods and properties from a parent class. It promotes code reusability and run-time polymorphism but can lead to rigid class hierarchies.
Composition implements a "has-a" relationship and is favored for code reuse where objects are composed of other objects. It offers more flexibility and avoids the tight coupling seen in inheritance. Composition allows objects to contain other objects, fostering easier maintenance and flexibility.
Decorator Pattern is a structural pattern that allows behavior to be added dynamically to an object at runtime without affecting other objects. Unlike inheritance, which happens at compile-time, decorators provide a flexible alternative, allowing functionalities to be composed as needed.

Each pattern addresses different use cases:

Use inheritance when objects share a clear hierarchical relationship.
Use composition for flexibility when creating complex objects.
Use decorators when you need to add functionality dynamically at runtime, without modifying existing class structures.

Java 21: The Magic Behind Virtual Threads

Abdelmajid E. — Wed, 29 May 2024 12:37:58 +0000

To understand virtual threads very well, we need to know how Java threads work.

Quick Introduction to Java Threads (Platform Threads) and How They Work

First, let's review the relationship between the threads we've been creating (Java threads) and the OS threads. Whenever we create an object of type Thread, that object, among other things, contains the code that needs to execute and the start method. When we run that start method, we ask the OS to create and start a new OS thread belonging to our application's process, and ask the JVM to allocate a fixed-size stack space to store the thread's local variables from that point on. The OS is fully responsible for scheduling and running the thread on the CPU, just like any other thread.

So, in a sense, that Thread object inside the JVM is just a thin layer or wrapper around an OS thread.

From now on, we're going to call this type of Java thread a platform thread. As we've already seen, those platform threads are expensive and heavy, because each platform thread maps 1-to-1 to an OS thread, which is a limited resource, and it is also tied to a static stack space within the JVM.

Introduction to Virtual Threads

Virtual threads are a relatively newer type of thread that has been introduced as part of JDK 19.

Like platform threads, virtual threads contain, among other things, the code we want to execute concurrently, and the start method. However, unlike a platform thread, a virtual thread fully belongs and is managed by the JVM and does not come with a fixed-size stack.

The OS takes no role in creating or managing it and is not even aware of it. In fact, a virtual thread is just like any Java object allocated on the heap and can be reclaimed by the JVM's garbage collection when it is no longer needed. The consequence of those facts is that unlike platform threads, which are very expensive to create and heavy to manage, virtual threads are very cheap and fast to create in large quantities.

Now, a good question you may ask at this point is: if virtual threads are just Java objects, how do they actually run on the CPU?

The answer is, as soon as we create at least one virtual thread, under the hood, the JVM creates a relatively small internal pool of platform threads. Whenever the JVM wants to run a particular virtual thread, for example, thread A, it mounts it on one of the platform threads within its pool.

When a virtual thread is mounted on a platform thread, that platform thread is called a carrier thread. If the virtual thread finishes its execution, the JVM will unmount that thread from its carrier and make that platform thread available for other virtual threads. That virtual thread object now becomes garbage, which the garbage collection can clean up at any time. However, in certain situations, if thread A has not finished but is unable to make any progress at that time, the JVM will unmount it but save its current state on the heap.

It's worth pointing out that we as developers have very little control over the carrier threads and the scheduling of the virtual threads on them. It is something that the JVM manages for us under the hood.

Quick Demo

For demonstration purposes, we will create a Java thread to see the difference between a virtual thread and a platform thread.

Platform Thread (Java Thread)

Inside your IDE, create a class with a main method, like this:



public class ThreadDemo {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            System.out.println("Thread: " + Thread.currentThread());
        });
        thread.start();
    }
}

So, let's create a virtual thread:



public class VirtualThreadDemo {
    public static void main(String[] args) {
        Thread.startVirtualThread(() -> {
            System.out.println("Virtual Thread: " + Thread.currentThread());
        });
    }
}

As you can see when we run the program, the first thing we notice is the object we printed is of type VirtualThread, then we see that its ID is 24, and the name is "ForkJoinPool.commonPool-worker-1". This tells us a few things. First, it tells us that to schedule this and any future virtual threads, the JVM created an internal thread pool of platform threads, which is called ForkJoinPool.commonPool, and then the JVM mounted our virtual thread on one of those worker threads, which is called worker-1.

To make this easier to understand, let's create another virtual thread:



public class VirtualThreadDemo {
    public static void main(String[] args) {
        Thread.startVirtualThread(() -> {
            System.out.println("Virtual Thread 1: " + Thread.currentThread());
        });
        Thread.startVirtualThread(() -> {
            System.out.println("Virtual Thread 2: " + Thread.currentThread());
        });
    }
}

As you can see, we have two virtual threads, their IDs are 24 and 25, respectively. They ran on the same pool of carrier threads, which is called ForkJoinPool.commonPool, but because we ran them concurrently, each one was mounted on a different worker thread to be its carrier. The first one was mounted on worker-1, and the second on worker-2.

Now, to see the relationship between the number of virtual threads and the number of platform threads within that ForkJoinPool, let's increase the number of virtual threads from 2 to 20:



public class VirtualThreadDemo {
    public static void main(String[] args) {
        for (int i = 0; i < 20; i++) {
            Thread.startVirtualThread(() -> {
                System.out.println("Virtual Thread " + (i + 1) + ": " + Thread.currentThread());
            });
        }
    }
}

As you can see on the screen, we indeed created 20 new virtual threads, each with its own unique ID. However, based on their names, we can see that the JVM dynamically decided to create a pool of seven platform threads to be their carriers, and all those virtual threads were scheduled to run on this small pool of threads.

Conclusion

I hope this blog is helpful to you, and I hope you enjoy it.

Setup Laravel 9 with JWT-Authentification

Abdelmajid E. — Fri, 01 Jul 2022 12:23:54 +0000

Are you looking to start building a project with backend laravel and send API requests using Rest API here is a good tutorial.

In this tutorial, I will build a simple backend project with laravel and Tymon JWT-auth.

Setup a Laravel Project using Composer
There are a few options when it comes to installing Laravel. We will be using Composer to setup the Laravel framework.

For this you will need to install the following:

Composer
Node
And for development, you will be needing PHP 8.

After installing all of this, we can simply run the following command to scaffold a complete Laravel project:

composer create-project Laravel/laravel laravel-jwt-rest-api

Setup a .env file database connexion

First, create a database by the same name of the project "laravel-jwt-rest-api", add connexion to .env file:



DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=laravel_jwt_rest_api
DB_USERNAME=root
DB_PASSWORD=

Now, Let's Install JWT Auth
composer require tymon/jwt-auth --ignore-platform-reqs
And you need to install laravel to generate jwt encryption keys. This command will create the encryption keys needed to generate secure access tokens:

php artisan jwt:secret

After successfully install laravel jwt, register providers. Open config/app.php . and put the bellow code :



'providers' => [
….
Tymon\JWTAuth\Providers\LaravelServiceProvider::class,
],
'aliases' => [
….
'JWTAuth' => 'Tymon\JWTAuth\Facades\JWTAuth',
'JWTFactory' => 'Tymon\JWTAuth\Facades\JWTFactory',
],

JWT auth package comes up with middlewares that we can use. Register auth.jwt middleware in

app/Http/Kernel.php



protected $routeMiddleware = [
        'auth' => \App\Http\Middleware\Authenticate::class,
        'auth.basic' => \Illuminate\Auth\Middleware\AuthenticateWithBasicAuth::class,
        'auth.session' => \Illuminate\Session\Middleware\AuthenticateSession::class,
        'cache.headers' => \Illuminate\Http\Middleware\SetCacheHeaders::class,
        'can' => \Illuminate\Auth\Middleware\Authorize::class,
        'guest' => \App\Http\Middleware\RedirectIfAuthenticated::class,
        'jwtAuth' => \App\Http\Middleware\JWTMiddleware::class,
        'password.confirm' => \Illuminate\Auth\Middleware\RequirePassword::class,
        'signed' => \Illuminate\Routing\Middleware\ValidateSignature::class,
        'throttle' => \Illuminate\Routing\Middleware\ThrottleRequests::class,
        'verified' => \Illuminate\Auth\Middleware\EnsureEmailIsVerified::class,
    ];

Now we need to modify User model. Open App/Models/User.php file and implement Tymon\JWTAuth\Contracts\JWTSubject interface. We also need to add two model methods getJWTIdentifier() and getJWTCustomClaims().



<?php

namespace App\Models;

use Illuminate\Contracts\Auth\MustVerifyEmail;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Foundation\Auth\User as Authenticatable;
use Illuminate\Notifications\Notifiable;
use Tymon\JWTAuth\Contracts\JWTSubject;

class User extends Authenticatable implements JWTSubject
{
    use HasFactory, Notifiable;

    /**
     * Get the identifier that will be stored in the subject claim of the JWT.
     *
     * @return mixed
     */
    public function getJWTIdentifier()
    {
        return $this->getKey();
    }

    /**
     * Return a key value array, containing any custom claims to be added to the JWT.
     *
     * @return array
     */
    public function getJWTCustomClaims()
    {
        return [];
    }
}

Next, the default authentication guard is web. We need to change it to api. Open config/auth.php file and change default guard to api.



<?php

return [


    'defaults' => [
        'guard' => 'api',
        'passwords' => 'users',
    ],


    'guards' => [
        'web' => [
            'driver' => 'session',
            'provider' => 'users',
        ],
        'api' => [
            'driver' => 'jwt',
            'provider' => 'users',
            'hash'=>false,
        ],
    ],

    'providers' => [
        'users' => [
            'driver' => 'eloquent',
            'model' => App\Models\User::class,
        ],
    ],


    'passwords' => [
        'users' => [
            'provider' => 'users',
            'table' => 'password_resets',
            'expire' => 60,
            'throttle' => 60,
        ],
    ],


    'password_timeout' => 10800,

];

Add Authentication routes

We need to register authentication routes into routes/api.php file. Open the file and add below routes into it.



// user
Route::post('/login',  [AuthController::class, 'login']);
Route::post('/register', [AuthController::class, 'register']);
Route::get('/logout', [AuthController::class, 'logout'])->middleware("jwtAuth");
Route::post('/refresh', [AuthController::class, 'refresh'])->middleware("jwtAuth");
Route::get('/user-profile', [AuthController::class, 'getUser'])->middleware("jwtAuth");

Create AuthController controller class

We have defined routes for authentication so far. We need to create a controller class to build application logic. The below Artisan command will generate a controller class at App/Http/Controllers/Api directory.



php artisan make:controller AuthController

In the controller class, add the methods as per routes.



<?php

namespace App\Http\Controllers\API;

use App\Http\Controllers\Controller;
use Validator;
use App\Models\User;
use Exception;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Tymon\JWTAuth\Exceptions\JWTException;
use Symfony\Component\HttpFoundation\Response;
use Tymon\JWTAuth\Facades\JWTAuth;

class AuthController extends Controller
{
    public $token = true;

    public function register(Request $request)
    {

         $validator = Validator::make($request->all(), 
                      [ 
                      'name' => 'required',
                      'email' => 'required|email',
                      'password' => 'required',  
                      'c_password' => 'required|same:password', 
                     ]);  

         if ($validator->fails()) {  

               return response()->json(['error'=>$validator->errors()], 401); 

            }   


        $user = new User();
        $user->name = $request->name;
        $user->email = $request->email;
        $user->password = bcrypt($request->password);
        $user->save();

        if ($this->token) {
            return $this->login($request);
        }

        return response()->json([
            'success' => true,
            'data' => $user
        ], Response::HTTP_OK);
    }

    public function login(Request $request)
    {
        $input = $request->only('email', 'password');
        $jwt_token = null;

        if (!$jwt_token = JWTAuth::attempt($input)) {
            return response()->json([
                'success' => false,
                'message' => 'Invalid Email or Password',
            ], Response::HTTP_UNAUTHORIZED);
        }

        return response()->json([
            'success' => true,
            'token' => $jwt_token,
            'user'=> Auth::user(),
            ]);
    }

    public function logout(Request $request)
    {

        try {
            JWTAuth::invalidate(JWTAuth::parseToken($request->token));

            return response()->json([
                'success' => true,
                'message' => 'User logged out successfully'
            ]);
        } catch (JWTException $exception) {
            return response()->json([
                'success' => false,
                'message' => 'Sorry, the user cannot be logged out'
            ], Response::HTTP_INTERNAL_SERVER_ERROR);
        }

    }

    public function getUser(Request $request)
    {
        try{
            $user = JWTAuth::authenticate($request->token);
            return response()->json(['user' => $user]);

        }catch(Exception $e){
            return response()->json(['success'=>false,'message'=>'something went wrong']);
        }
    }
}

We have created methods for authenticating APIs for Login, Register, getUser, Token Refresh, and Logout routes.

Create JWTMiddleware controller class

We need to protect our routes before the user gets into the controllers, for that we need to create a middleware JWTMiddleware using the command :



php artisan make:middleware JWTMiddleware

The JWTMiddleware contains the verification of the Token sent with API.




<?php

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use Tymon\JWTAuth\Facades\JWTAuth;

class JWTMiddleware
{
    /**
     * Handle an incoming request.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Closure(\Illuminate\Http\Request): (\Illuminate\Http\Response|\Illuminate\Http\RedirectResponse)  $next
     * @return \Illuminate\Http\Response|\Illuminate\Http\RedirectResponse
     */
    public function handle(Request $request, Closure $next)
    {
        $message = '';
        try {
            // check validation of the token
            JWTAuth::parseToken()->authenticate();
            return $next($request);
        } catch (\Tymon\JWTAuth\Exceptions\TokenExpiredException $e) {
            $message = 'Token expired';
        } catch (\Tymon\JWTAuth\Exceptions\TokenInvalidException $e) {
            $message = 'Invalid token';
        } catch (\Tymon\JWTAuth\Exceptions\JWTException $e) {
            $message = 'Provide token';
        }
        return response()->json(['success' => false, 'message' => $message]);
    }
}

Do the migration

First, you need to create a database by the name laravel_jwt_rest_api,then run this command :



php artisan migrate

Test application in Postman

We have completed the application coding. Start the Laravel server using below Artisan command.



php artisan serve

For testing APIs, we will use Postman application. Postman is an API platform for building and using APIs. We will test all API. Lets start from register API.

Register API

All API routes are prefixed with api namespace. In the postman use http://127.0.0.1:8000/api/register API endpoint. Pass name, email, password and c_password parameters into request. You will get message and user details into response.

Login API

Use http://127.0.0.1:8000/api/login API endpoint with email password parameter with request. If the email and password matches with registered user, you will receive token json object into response

GetUser API

All JWTMiddleware middleware routes are protected with api guard. You need to pass access_token in Header as bearer token.

Logout API

To logout the user, you need to invalidate the current token. You can simply call auth()->logout() method to invalidate current access token. Once user, logged out, it can't access protected routes.

Conclusion

Eventually, our tutorial is over. We have learned how to implement JWT authentication in Laravel application. In the next tutorial, we will use JWT token for REST API.

I hope, this tutorial will help on your development. If you liked this tutorial, please consider to share with your friends.