Orbis: The Magic of Abstraction in PHP

Have you ever wondered how to simplify complex functionality in PHP in an elegant and reusable way? Introducing 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 functionality into simple, reusable components. Imagine being able to encapsulate all of your 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 of 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 incredibly powerful functionality. Orbis allows:

1. Each file has its own router
2. Routes are 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 caching 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;
    }
}

// Registrando diferentes instâncias para diferentes contextos
Orbis::register(new SmartCache(), 'user.cache');
Orbis::register(new SmartCache(), 'product.cache');

// Em qualquer lugar da sua aplicação
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 cache usage tracking
4. Optimized Performance: Instances are automatically reused

Using Orbis in Your Project

Installation via Composer:

composer require lithemod/orbis

Basic Example:

// Registre uma instância
Orbis::register(MyClass::class);

// Use em qualquer lugar
$instance = Orbis::instance(MyClass::class);

Conclusion ?

Orbis isn't 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
• Facilitate testing and maintenance

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

To better understand 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!