To configure the automatic loading of Composer's classmap, first use the "classmap" key under "autoload" in composer.json to specify the directory or file. For example: {"autoload": {"classmap": ["lib/", "database/models/"]}}, Composer will scan the .php file in these paths and generate class maps. You can also specify a single file such as legacy_class.php. After updating the configuration, run composer dump-autoload to regenerate the autoloader. The production environment can use --optimize optimization performance. Compared to PSR-4, classmap is suitable for legacy code that does not follow namespace specifications. It should be noted that classmap parses all specified files, which may affect performance. Therefore, it should be as simple as possible to streamline the directory scope and avoid duplication of classes defined by PSR-4. If you use PSR-4 and classmap at the same time, you need to ensure that the paths of the two need to be conflicted, for example: "psr-4": {"App\": "src/"}, "classmap": ["legacy_code/"]}. Finally, after modifying the contents of the classmap directory, you must re-execute the dump-autoload command.

To set up classmap autoloading in your composer.json , you need to define the directories or files where Composer should look for classes to autoload using the classmap method. This is useful when working with legacy code or projects that don't follow PSR-4 standards.

What Is Classmap Autoloading?

Classmap autoloading works by scanning specific directories or files, parsing all the PHP classes they contain, and generating a map of class names to file paths. This map is then used at runtime to load classes efficiently.

Unlike PSR-4 autoloading, which relies on namespace-to-directory mappings, classmap doesn't care about namespaces or file structure — it just reads every class it finds in the specified locations and builds a lookup table.

How to Configure Classmap in composer.json

To enable classmap autoloading, edit your composer.json and add entries under the "autoload" section using the "classmap" key.

Here's an example:

 {
  "autoload": {
    "classmap": ["lib/", "database/models/"]
  }
}

In this setup:

• lib/ and database/models/ are directories containing PHP classes.
• Composer will scan each .php file in these directories and generate a classmap for them.

You can also specify individual files if needed:

 {
  "autoload": {
    "classmap": ["legacy_class.php", "helpers/functions.php"]
  }
}

This is especially handy for files that contain procedural code or old-style classes that don't use namespaces properly.

After updating the composer.json , run this command to regenerate the autoloader:

 composer dump-autoload

If you're in production and want to optimize performance, you can use:

 composer dump-autoload --optimize

This generates a more efficient classmap by including only the necessary files.

When Should You Use Classmap instead of PSR-4?

Use classmap autoloading when:

• You're dealing with legacy codebases that don't follow PSR-4 naming conventions.
• You have a mix of procedural functions and classes without proper namespace structures.
• You want to avoid relying on predictable file paths based on namespace (which is required by PSR-4).

PSR-4 is generally preferred for modern PHP applications because it's faster and cleaner — it loads classes on demand rather than scanning everything upfront. But classmap is a solid fallback when you're working with older systems or irregular code layouts.

One thing to keep in mind: classmap autoloading requires Composer to scan and parse every file listed during dump-autoload . So if you have many large directories, this can slow down the autoloader generation process.

Tips for Managing Classmap Efficiently

• Keep your classmap directories as focused as possible. Only include what you need.
• Avoid adding too many top-level directories — it makes Composer do extra work.
• If you're mixing PSR-4 and classmap, make sure there's no overlap in class definitions.
• Don't forget to re-run composer dump-autoload after adding or removing classes from a classmap directory.

If you're maintaining both PSR-4 and classmap sections, your composer.json might look like this:

 {
  "autoload": {
    "psr-4": {
      "App\\": "src/"
    },
    "classmap": ["legacy_code/"]
  }
}

This way, modern code benefits from PSR-4 efficiency, while legacy code still gets loaded correctly.

Basically that's it.

The above is the detailed content of How do I configure classmap autoloading in my composer.json file?. For more information, please follow other related articles on the PHP Chinese website!