It is possible to use an autoload system, based on the autoload function of PHP (the class file is loading automatically when the class is used). It avoids to use jClasses (see below). The autoload system of Jelix supports the PSR0 specification and the PSR-4 specification.

If you are using Composer, it is possible to declare namespaces in the composer.json file of your application, but modules will be less reusable. Except if you develop a module in its own repository, and if it is installable with Composer.

An alternative way is to declare classes and namespaces in the module.xml file, in a <autoload> element.

Here is an example:

<module xmlns="http://jelix.org/ns/module/1.0">
   <info id="jelix_tests@testapp.jelix.org" name="jelix_tests"> ... </info>
   <dependencies> ... </dependencies>
   <autoload>
        <class name="myautoloadedclass" file="autoloadtest/autoloadtestclass.php" />
        <classPattern pattern="/^myalclass/" dir="autoloadtest/withpattern/" suffix=".cl.php" />
        <psr0 name="jelixTests\foo" dir="autoloadtest" />
        <psr4 name="jelixTests\bar" dir="autoloadtest/barns" suffix=".class.php" />
        <includePath dir="autoloadtest/incpath" suffix=".php" />
        <autoloader file="autoloadtest/myautoloader.php" />
   </autoload>
</module>

As you can see, there are different way to declare a class. Path of file or directory indicated in tags should be relative to the module directory.

To load a specific class, just indicate its name and its file:

   <class name="myautoloadedclass" file="autoloadtest/autoloadtestclass.php" />

To declare several classes that have similar name, you can use a regular expression and indicate the directory where files are. You can indicate also a suffix for the filename:

   <!-- load automatically classes that have names beginning by myalclasse -->
  <classPattern pattern="/^myalclass/" dir="autoloadtest/withpattern/" suffix=".cl.php" />

To declare a set of classes that have a specific namespace, indicate the namespace and a directory in a <psr0> element. You can use also the deprecated element <namespace>, they are equivalent.

  <psr0 name="jelixTests\foo" dir="autoloadtest" />
  <!-- or -->
  <namespace name="jelixTests\foo" dir="autoloadtest" />

This behavior follows the PSR0 specification. So the namespace should correspond to a path in the indicated directory. For example, if Jelix should load the class jelixTests\foo\bar\baz, it will load the file autoloadtest/jelixTests/foo/bar/baz.php.

Jelix have an other namespace support, which follow PSR-4 specification. You should then use the <psr4> element, or the deprecated element <namespacePathMap>.

   <psr4 name="jelixTests\bar" dir="autoloadtest/barns" suffix=".class.php" />
   <!-- or -->
   <namespacePathMap name="jelixTests\bar" dir="autoloadtest/barns" suffix=".class.php" />

The class path does not correspond to the name of the namespace. It indicates that all classes which have the indicated namespace are directly in the given directory. So the class jelixTests\foo\bar\baz is not in the file autoloadtest/jelixTests/foo/bar/baz.class.php but in autoloadtest/bar/baz.class.php.

It is possible to indicate a classical include path (like the includePath of PHP): Jelix will search a file which have the same name of the class in this directory.

   <includePath dir="autoloadtest/incpath" suffix=".php" />

Last possibility: it is possible to indicate a file that initialize an other autoloader. It can be useful when you use a vendor libraries which have its own autoloader. This autoloader should use the function spl_autoload_register and its parents.

   <autoloader file="autoloadtest/myautoloader.php" />

jClasses is a component which is responsible to find, load and instancy classes provided by your module. It avoids to include and instancy by yourself.

Historically, this component was created into Jelix before namespaces were appeared into PHP. As jClasses needs a selector, you don't have to indicate a path to the class. You can then load easily a class from an other module.

However, since the existence of namespaces and of the auto-loading, the use of jClasses is less relevant. It is still interesting if you need singleton or use a class as a service.

Services classes ¶

Creating a class for jClasses ¶

  
   class StockService {
      public function getProductsList(){
          $stock = jDAO::get("products");
          
          $list = $stock->findAll();
          
          // here : processing of the list (for example)
          
          return $list;      
      }
   }

Instantiation with jClasses ¶

    $stocksrv = jClasses::getService("shop~stockservice");
    $rep->body->assign('product_list', $stocksrv->getProductList());

   $stocksrv = jClasses::getService("shop~stocks/stockservice");

Including classes with jClasses ¶

    jClasses::inc('shop~shoesProduct');
    $shoe = new shoesProduct('43', 'black');

Including interfaces with jClasses ¶

interface IStockUtils {
    […]
}

jClasses::incIface('commons~interfaces/IStockUtils');

class stockUtils implements IStockUtils {
    […]
}

You have often to use some classes provided by other projects. Of course, you can use it into a Jelix application.

With Composer ¶

Legacy practice ¶

   require(jApp::getModulePath('main') . 'classes/bar.php');
   $myclass = new bar();

   $myclass = jClasses::create('bar');

   // or if the constructor need arguments
   jClasses::inc('bar');
   $myclass = new bar('bla');

   require(jApp::appPath('lib/foo/bar.php'));
   $myclass = new bar();