How to Use Orbis to Simplify Your PHP Code

If you've ever felt overwhelmed by the complexity of managing instances and dependencies in PHP, Orbis might be the solution for you! It’s a powerful tool that abstracts and organizes instance management in a simple, efficient, and reusable way. In this post, we will teach you how to use Orbis to make your PHP code cleaner and more organized.

What is Orbis? 🤔

Orbis is a global instance management class that allows you to register and retrieve objects in a simple and reusable way. Imagine needing multiple instances of the same type of object in different contexts of your application—Orbis makes this easy without the hassle.

Installing Orbis 🚀

To get started with Orbis, you first need to install it via Composer. Run the following command in your terminal:

composer require lithemod/orbis

This will install Orbis and all its necessary dependencies into your project.

How to Use Orbis: Step by Step 📚

1. Register an Instance

To register an instance in Orbis, use the Orbis::register() method. This method takes two parameters:

• The first parameter is the instance of the object you want to register.
• The second parameter is a unique key (usually a string) that identifies this instance.

Example:

use Orbis\Orbis;

class DatabaseConnection {
    public function connect() {
        return 'Connected to the database';
    }
}

// Registering an instance
Orbis::register(new DatabaseConnection(), 'db.connection');

2. Retrieving the Instance

After registering the instance, you can retrieve it anywhere in your application using Orbis::instance(). The key used during registration is passed as an argument to retrieve the corresponding object.

Example:

// Retrieving the registered instance
$db = Orbis::instance('db.connection');
echo $db->connect(); // Output: Connected to the database

3. Using Orbis with Multiple Contexts

One of the great advantages of Orbis is that you can register different instances for different contexts. This allows you to have isolated instances in different parts of your application without them interfering with each other.

Example with different caches for users and products:

class Cache {
    private array $storage = [];

    public function set(string $key, mixed $value): void {
        $this->storage[$key] = $value;
    }

    public function get(string $key): mixed {
        return $this->storage[$key] ?? null;
    }
}

// Registering different caches for users and products
Orbis::register(new Cache(), 'user.cache');
Orbis::register(new Cache(), 'product.cache');

// Using the caches
$userCache = Orbis::instance('user.cache');
$userCache->set('user_1', 'User Data');
echo $userCache->get('user_1'); // Output: User Data

$productCache = Orbis::instance('product.cache');
$productCache->set('product_1', 'Product Data');
echo $productCache->get('product_1'); // Output: Product Data

4. Applying Orbis in Different Contexts

With Orbis, you can easily register and use different instances depending on the context of your application. This helps isolate state and logic, making your code more modular and maintainable.

Advantages of Using Orbis ✨

1. Simplicity and Ease of Use: Registering and retrieving instances is simple and straightforward.
2. Context Isolation: Different parts of your app can use separate instances without conflicts.
3. Zero Configuration: No need to configure anything other than registering the instances, keeping the app clean and easy to understand.
4. Instance Reuse: Instances can be reused in different parts of your app without needing reconfiguration.

Full Example

Here is a full example demonstrating the use of Orbis instances in a user and product management application:

use Orbis\Orbis;

class User {
    public string $name;

    public function __construct(string $name) {
        $this->name = $name;
    }
}

class Product {
    public string $name;

    public function __construct(string $name) {
        $this->name = $name;
    }
}

// Registering instances
Orbis::register(new User('John Doe'), 'user.john');
Orbis::register(new Product('Laptop'), 'product.laptop');

// Retrieving and using instances
$user = Orbis::instance('user.john');
echo $user->name; // Output: John Doe

$product = Orbis::instance('product.laptop');
echo $product->name; // Output: Laptop

Conclusion 🎯

Orbis is a powerful tool that makes instance management in PHP simpler and more organized. By using Orbis, you can:

• Reduce code complexity
• Improve modularity and reusability
• Isolate state in different contexts
• Organize your application better

With Orbis, you can create cleaner, more efficient, and maintainable PHP systems. Try it out today!