PHPackages                             kassko/class-resolver - PHPackages - PHPackages  [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register)

1. [Directory](/)
2. /
3. [Utility & Helpers](/categories/utility)
4. /
5. kassko/class-resolver

ActiveLibrary[Utility & Helpers](/categories/utility)

kassko/class-resolver
=====================

Retrieve an object from a class name.

v1.0.0(4y ago)039.2k↓50%2PHPPHP >=5.5.0

Since Sep 4Pushed 4y ago1 watchersCompare

[ Source](https://github.com/kassko/class-resolver)[ Packagist](https://packagist.org/packages/kassko/class-resolver)[ RSS](/packages/kassko-class-resolver/feed)WikiDiscussions master Synced 1mo ago

READMEChangelog (10)DependenciesVersions (18)Used By (2)

class-resolver
==============

[](#class-resolver)

[![Latest Stable Version](https://camo.githubusercontent.com/9503909a590a2f55857062a0729b7055e9b18af6910450097ae3b03abd9de3c0/68747470733a2f2f706f7365722e707567782e6f72672f6b6173736b6f2f636c6173732d7265736f6c7665722f762f737461626c652e706e67)](https://packagist.org/packages/kassko/class-resolver)[![Total Downloads](https://camo.githubusercontent.com/0964329524cbbc349b948997aa5d6796263cbb271077e64d09ebb56113f35ce6/68747470733a2f2f706f7365722e707567782e6f72672f6b6173736b6f2f636c6173732d7265736f6c7665722f646f776e6c6f6164732e706e67)](https://packagist.org/packages/kassko/class-resolver)[![Latest Unstable Version](https://camo.githubusercontent.com/1d934dfd829e184ee24b7f2dd152b082106d8a4464746362775e357a7a891cfd/68747470733a2f2f706f7365722e707567782e6f72672f6b6173736b6f2f636c6173732d7265736f6c7665722f762f756e737461626c652e706e67)](https://packagist.org/packages/kassko/class-resolver)

Allows to create an object with dependencies from it's class name.

Installation
------------

[](#installation)

You can install this component with composer `composer require kassko/class-resolver:some_version`

Usage
-----

[](#usage)

### Use the class-resolver

[](#use-the-class-resolver)

Imagine, you need to create a cache instance and you have only the cache class name.

In the simpliest case, you can go for such code:

```
class ClientClass
{
    /**
     * @var string
     */
    private $cacheClass;

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

    public function clientFunction()
    {
        //...
        $myCacheInstance = new $this->cacheClass;
        //...
    }
}
```

If the cache class has some dependencies, you can use the class-resolver and go through this kind of code:

```
use Kassko\ClassResolver\ClassResolverInterface;

class ClientClass
{
    /**
     * @var string
     */
    private $cacheClass;
    /**
     * @var ClassResolverInterface $classResolver
     */
    private $classResolver;

    public function __construct($cacheClass, ClassResolverInterface $classResolver)
    {
        $this->cacheClass = $cacheClass;
        $this->classResolver = $classResolver;
    }

    public function clientFunction()
    {
        //...
        $myCacheInstance = $this->classResolver->resolve($this->cacheClass);
        //...
    }
}
```

If you need to handle yourself the case when the class cannot be resolved with the class-resolver, you can go through such code:

```
use Kassko\ClassResolver\ClassResolverInterface;

class ClientClass
{
    /**
     * @var string
     */
    private $cacheClass;
    /**
     * @var ClassResolverInterface $classResolver
     */
    private $classResolver;

    public function __construct($cacheClass, ClassResolverInterface $classResolver)
    {
        $this->cacheClass = $cacheClass;
        $this->classResolver = $classResolver;
    }

    public function clientFunction()
    {
        //...
        if ($this->classResolver->support($this->cacheClass)) {
            $myCacheInstance = $this->classResolver->resolve($this->cacheClass);
        } else {
            //Here, the code that handle the case when the class cannot be resolved.
        }
        //...
    }
}
```

### Feed the class-resolver

[](#feed-the-class-resolver)

There are severals ways to feed the class-resolver. Each way of feeding has it's own class-resolver implementation.

#### From a map [`Kassko\ClassResolver\MapClassResolver`](src/MapClassResolver.php)

[](#from-a-map-kasskoclassresolvermapclassresolver)

```
use Kassko\ClassResolver\MapClassResolver;

$mapClassResolver = new MapClassResolver(['Kassko\Sample\CacheClass' => $cacheInstance]);
```

You can use a closure for lazy loading:

```
use Kassko\ClassResolver\MapClassResolver;

$mapClassResolver = new MapClassResolver(['Kassko\Sample\CacheClass' => function () use ($cacheInstance) {return new Kassko\Sample\CacheClass(new Kassko\Sample\Dependency);};
```

#### From a container by providing the `get` method, and the `has` method.

[](#from-a-container-by-providing-the-get-method-and-the-has-method)

```
$classResolver = new VariableContainerAwareClassResolver($container, 'get', 'has');
```

The `get` method is the method that resolves the service and the `has` method is the method that checks if the service exists.

#### From a container adapter that implements [`Kassko\ClassResolver\ContainerInterface`](src/ContainerInterface.php)

[](#from-a-container-adapter-that-implements-kasskoclassresolvercontainerinterface)

```
$container = new MyContainerAdapter($container);
$classResolver = new ContainerAwareClassResolver($container);
```

You can find an adapter in the bundle class-resolver-bundle. This is [`an adapter for Symfony container`](https://github.com/kassko/class-resolver-bundle/blob/master/src/Adapter/Container/SymfonyContainerAdapter.php).

#### From a closure

[](#from-a-closure)

```
$container = new MyContainerAdapter($container);
$cacheInstance = new Kassko\Sample\CacheClass($someDependency);

$classResolver = new ClosureClassResolver(function ($className) {
    switch ($className) use ($cacheInstance) {
        case 'Kassko\Sample\CacheClass':
            return $cacheInstance;
    }
});
```

#### From a factory

[](#from-a-factory)

```
class CacheFactory
{
    public function supports($className) {return 'Kassko\Sample\CacheClass' === $className;}
    public function get($className) {return new $className;}
}

$factory = new FactoryAdapterClassResolver();
$classResolver = new ContainerAwareClassResolver($factory, 'supports', 'get');
```

#### From a static factory

[](#from-a-static-factory)

```
class CacheFactory
{
    public static function supports($className) {return 'Kassko\Sample\CacheClass' === $className;}
    public static function get($className) {return new $className;}
}

$classResolver = new ContainerAwareClassResolver('StaticFactoryAdapterClassResolver', 'supports', 'get');
```

#### From others class-resolver

[](#from-others-class-resolver)

```
$classResolver = new ClassResolverChain();
$classResolver->add($mapClassResolver);
$classResolver->add($closureClassResolver);
```

If no resolver can handle the className, a basic `new $className` is performed.

You can change this behaviour so that an exception `Kassko\ClassResolver\NotResolvedClassException` is thrown instead.

```
use Kassko\ClassResolver\DefaultClassResolver;

$classResolver = new ClassResolverChain();
$classResolver->add($mapClassResolver);
$classResolver->add($closureClassResolver);
$classResolver->setDefaultResolver(new DefaultClassResolver(['throw_exception']));
```

Or you can provide your own default resolver implementation to `setDefaultResolver()` method.

###  Health Score

35

—

LowBetter than 79% of packages

Maintenance20

Infrequent updates — may be unmaintained

Popularity26

Limited adoption so far

Community11

Small or concentrated contributor base

Maturity67

Established project with proven stability

 Bus Factor1

Top contributor holds 100% of commits — single point of failure

How is this calculated?**Maintenance (25%)** — Last commit recency, latest release date, and issue-to-star ratio. Uses a 2-year decay window.

**Popularity (30%)** — Total and monthly downloads, GitHub stars, and forks. Logarithmic scaling prevents top-heavy scores.

**Community (15%)** — Contributors, dependents, forks, watchers, and maintainers. Measures real ecosystem engagement.

**Maturity (30%)** — Project age, version count, PHP version support, and release stability.

###  Release Activity

Cadence

Every ~179 days

Recently: every ~601 days

Total

16

Last Release

1584d ago

Major Versions

v0.3.3.0 → v1.0.02021-12-03

### Community

Maintainers

![](https://www.gravatar.com/avatar/9fac4367e85288a508e3720645e35b3cbe119b93e06b2d8a382b0a375413a561?d=identicon)[kassko](/maintainers/kassko)

---

Top Contributors

[![kassko](https://avatars.githubusercontent.com/u/8608325?v=4)](https://github.com/kassko "kassko (31 commits)")

---

Tags

factorydependencyinjectionclassresolver

### Embed Badge

![Health badge](/badges/kassko-class-resolver/health.svg)

```
[![Health](https://phpackages.com/badges/kassko-class-resolver/health.svg)](https://phpackages.com/packages/kassko-class-resolver)
```

###  Alternatives

[composer/composer

Composer helps you declare, manage and install dependencies of PHP projects. It ensures you have the right stack everywhere.

29.4k187.2M2.6k](/packages/composer-composer)[symfony/property-access

Provides functions to read and write from/to an object or array using a simple string notation

2.8k295.3M2.5k](/packages/symfony-property-access)[php-di/invoker

Generic and extensible callable invoker

26857.8M56](/packages/php-di-invoker)[nette/robot-loader

🍀 Nette RobotLoader: high performance and comfortable autoloader that will search and autoload classes within your application.

89152.7M321](/packages/nette-robot-loader)[bamarni/composer-bin-plugin

No conflicts for your bin dependencies

52722.0M859](/packages/bamarni-composer-bin-plugin)[contributte/di

Extra contrib to nette/di

465.8M18](/packages/contributte-di)

PHPackages © 2026

[Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)