Business classes and services in Jelix are classic PHP classes which have nothing specific. The only thing that you have to respect is to specify it in a file named name_of_class.class.php in the classes/ directory of the module, so it can be loaded by jClasses:

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

This class must be placed in classes/StockService.class.php.

The difference between a service class and the other classes is that a service class gives... a service. It doesn't need to be instanciated each time we use it because it doesn't have "discriminating" property. Only one instance is enough for all the application.

For example, a "factory" type class, which retrieves sets of data, is a service class. On the other hand, a class representing a product, which thus has identifying fields, is a non service class.

Jelix proposes the jClasses class, which avoids to do an include and instantiate yourself.

jClasses gives two static methods, to which you give a selector:

• createInstance($ClassSelector) (or create($ClassSelector) )
• getService($ClassSelector)

The first will, for each call, give a new instance. The second will allways give the same instance of the class. getService will thus be used for the service classes, and createInstance for the others.

If our StockService class is in the "shop" module, here is an example in a controller:

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

Notice that you can put classes in sub-directories of the classes/ directory. For example, you can store the StockService file into classes/stocks/. Then, to call it:

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

In some cases, like when the constructor needs parameters, you have to include the class and then instantiate it "manually".

In this case the jClasses class has a static method inc($ClassSelector). It includes (require_once) the class specified by the selector.

Example:

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

You can also use the autoload system of PHP, see below.

jClasses provides the static methods incIFace to include PHP interfaces stored in a classes directory of a module.

An interface should be store in a *.iface.php file. To declare a IStockUtils interface, store this content into the file classes/interfaces/IStockUtils.iface.php:

interface IStockUtils {
    […]
}

Then to include this interface, stored in the module commons, into file that need it:

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

class stockUtils implements IStockUtils {
    […]
}

Sometimes, you may want to store some of your business object in sessions. But then your classes should be loaded before the session_start() call, so PHP can unserialize this objects.

Before the autoload system (see below), Jelix provided a way to indicates which classes to load before the session_start(). In the configuration, in the sessions section, you should indicate the selectors of this classes in the loadClasses options:

[sessions]

loadClasses = "mymodule~bar,mymodule~subdir/foo, shop~shoesProduct"

The module name is required in selectors.

• *Note: this loadClasses parameter is now deprecated. You must declare**
• *your classes in module.xml files, so they will be auto-loaded.** See below.

Use the autoload system only for classes that are often used, or that share a common namespace. Declaring dozen classes that does not share a namespace, does not have a sens, and will slow the autoload system of PHP, because it should verify then many name and path. So prefer to use jClasses, for classes used only by the module or used only few times, or create classes which share same root namespace.

Composer is a package manager for PHP. You can install easily many vendors libraries. We recommand to use this tool (Next version of Jelix 1.6+ will be installable with Composer ;-)).

To integrate Composer packages into your Jelix application, it is very simple:

• create your composer.json file into your application (see Composer documentation)
• install packages indicated into your composer.json: php composer.phar install. It generates a vendor/ directory into your application
• Include the file vendor/autoload.php into application.init.php

require (__DIR__.'/vendor/autoload.php');
require (__DIR__.'/../lib/jelix/init.php');
jApp::initPaths( /* ... */ );
jApp::setTempBasePath( /* ... */ );

If you don't want to use Composer, here is an other way to integrate vendor libraries in your application.

Although you can store this classes where you want (because the require or include statement are not restricted), it's better to store them:

• into the lib/ directory
• or into the classes/ directory of a module
• or into the lib/ directory of a module

Global installation ¶

   require(LIB_PATH.'foo/bar.php');
   $myclass = new bar();

Installation in a module ¶

   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');