Orbis: The Magic of Abstraction in PHP

Have you ever wondered how to simplify complex functionalities in PHP in an elegant and reusable way? We present Orbis, a revolutionary tool that transforms the way we manage instances and abstractions in PHP.

What is Orbis? ?

Orbis is a powerful class that acts as a global instance manager, allowing you to abstract complex functionalities into simple, reusable components. Imagine being able to encapsulate all routing, configuration, and state management logic in a single line of code!

The Magic Behind Orbis ✨

To understand the true power of Orbis, let's look at a real example from the Lithe framework:

function get(string $path, callable|array ...$handler): void {
    $caller = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 1)[0];
    $key = strtolower($caller['file']);

    $router = Orbis::instance($key);
    if (!$router instanceof Router) {
        throw new Exception("Invalid router instance: Router not found");
    }

    $router->get($path, ...$handler);
}

This seemingly simple code hides an incredibly powerful functionality. Orbis allows:

1. Each file to have its own router.
2. Routes to be automatically managed and organized.
3. No conflicts between different parts of the application.

A Practical Example That Will Surprise You ?

Let's create a smart cache system using Orbis:

class SmartCache {
    private array $storage = [];
    private array $analytics = [];

    public function set(string $key, mixed $value, int $ttl = 3600): void {
        $this->storage[$key] = [
            'value' => $value,
            'expires' => time() + $ttl,
            'hits' => 0
        ];
    }

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

        if (time() > $this->storage[$key]['expires']) {
            unset($this->storage[$key]);
            return null;
        }

        $this->storage[$key]['hits']++;
        $this->analytics[$key] = ($this->analytics[$key] ?? 0) + 1;

        return $this->storage[$key]['value'];
    }

    public function getAnalytics(): array {
        return $this->analytics;
    }
}

// Registering different instances for different contexts
Orbis::register(new SmartCache(), 'user.cache');
Orbis::register(new SmartCache(), 'product.cache');

// Anywhere in your application
function cacheUser(User $user): void {
    $cache = Orbis::instance('user.cache');
    $cache->set("user.{$user->id}", $user);
}

function getUser(int $id): ?User {
    $cache = Orbis::instance('user.cache');
    return $cache->get("user.{$id}");
}

Why Is This Revolutionary? ?

1. Automatic Isolation: Each context has its own cache instance.
2. Zero Configuration: No need to configure anything in bootstrap or providers.
3. Integrated Analytics: Automatic tracking of cache usage.
4. Optimized Performance: Instances are automatically reused.

Using Orbis in Your Project

Installation via Composer:

composer require lithemod/orbis

Basic Example:

// Register an instance
Orbis::register(MyClass::class);

// Use it anywhere
$instance = Orbis::instance(MyClass::class);

Conclusion ?

Orbis is not just another dependency management library – it’s a new way of thinking about abstraction and code reuse in PHP. With it, you can:

• Simplify complex code.
• Improve project organization.
• Reduce coupling between components.
• Make testing and maintenance easier.

Try Orbis today and discover how it can transform your PHP code into something truly magical! ✨

To understand more about how Orbis works, read the post How to Use Orbis to Simplify Your PHP Code and discover its potential in practice!

The above is the detailed content of Orbis: The Magic of Abstraction in PHP. For more information, please follow other related articles on the PHP Chinese website!