Wiki - 1 output

Événement déclenché après la fin de transaction d’enregistrement d’un objet de la classe.

/**
 * @after_commit [callable]
 */
class A_Name

Cette annotation indique à l’objet lien de données qu’il devra appeler la méthode indiquée après chaque commit de transaction impliquant l’enregistrement d’un objet de la classe.

• Si la méthode est dans la même classe, elle est appelée dans le contexte de l’objet qui vient d’être écrit par le lien de données.
  Le lien de données et les options qui ont été utilisées pour l’écriture sont envoyées comme argument à la méthode.
• Si la méthode est dans une classe tierce, il doit s’agir d’une méthode statique dont le premier argument sera l’objet qui vient d’être écrit, et les arguments suivant le lien de données puis un tableau contenant les options qui ont été utilisées pour l’écriture.

Exemples

Exemple dans la même classe

Dans l’exemple ci-dessous, la méthode appelée est dans la même classe.
Un texte apparaîtra après chaque commit de transaction impliquant l’enregistrement d’un objet de classe Car , à remplacer par tout traitement de votre choix.

namespace ITRocks\Examples\After_Commit;
 
use ITRocks\Framework\Dao\Data_Link;
use ITRocks\Framework\Dao\Option;
 
/**
 * A car business object example
 *
 * @after_commit afterCommitCar
 */
class Car
{
 
	/**
	 * @var string
	 */
	public $color;
 
	/**
	 * @param $link    Data_Link
	 * @param $options Option[]
	 */
	public function afterCommitCar(Data_Link $link, $options)
	{
		// Do what you have to do after each write of a car here
		echo 'Doing things inside Car' . BR;
	}
 
	/**
	 * @return string
	 */
	public function __toString()
	{
		return $this->color . SP . 'car';
	}
 
}

Contexte d’appel

Dans l’exemple ci-dessus, le moment exact ou la méthode est appelée est lors de l’appel à la méthode commit du lien de données.

Exemple d’appel déclenchant l’événement :

Dao::begin();
$car        = Dao::searchOne(['color' => blue]);
$car->color = 'red';
Dao::write($car);
// la méthode afterCommitCar est appelée lors de l'appel ci-dessous
Dao::commit();

• Si write est appelé en dehors d’un contexte de transaction, l’appel a lieu immédiatement à la fin de l’écriture.
• Si plusieurs transactions sont imbriquées, l’appel a lieu à la fin de la transaction de plus haut niveau, c’est à dire lors du commit effectivement transmis au moteur de base de données transactionnelle.

Le principe est que ces événements @after_commit ne soient appelé que lorsque les données sont persistées en base, pas seulement du point de vue de la transaction courante comme avec @after_write, mais du point de vue de toute session de connexion au lien de donnée, même externe.

Exemple dans une classe tierce

Dans cet autre exemple, la méthode appelée est dans une autre classe, et obligatoirement statique.

La classe métier :

namespace ITRocks\Examples\After_Commit;
 
use ITRocks\Examples\After_Commit\After_Commit_Class;
 
/**
 * A car business object example
 *
 * @after_commit After_Commit_Class::afterCommitCar
 */
class Car
{
 
	/**
	 * @var string
	 */
	public $color;
 
}

La méthode est appelée de manière statique dans la classe tierce After_Commit_Class :

namespace ITRocks\Examples\after_commit;
 
use ITRocks\Framework\Dao\Data_Link;
use ITRocks\Framework\Dao\Option;
 
/**
 * This class stores things done after commit calls
 */
class After_Commit_Class
{
 
	/**
	 * @param $car     Car
	 * @param $link    Data_Link
	 * @param $options Option[]
	 */
	public static function afterCommitCar(Car $car, Data_Link $link, $options)
	{
		// Do what you have to do after each write of a car here
		echo 'Doing things outside Car' . BR;
	}
 
}

Écriture compacte

Si aucun nom de méthode n’est indiqué, la méthode appelée sera static::afterCommit().
Exemple de classe métier :

namespace ITRocks\Examples\after_commit;
 
/**
 * A simple car business class example
 *
 * @after_commit
 */
class Car
{
 
	/**
	 * @var string
	 */
	public $color;
 
	/**
	 * This will be called by the Dao after each write of a Car object
	 */
	public function afterCommit()
	{
		// Do what you have to do after each write of a car here
		echo 'Doing things inside Car' . BR;
	}
 
	/**
	 * @return string
	 */
	public function __toString()
	{
		return $this->color . SP . 'car';
	}
 
}

Appels multiples

On peut appeler plusieurs traitements, en répétant simplement l’annotation dans la classe métier.
Ici par exemple on va appeler les deux méthodes : celle dans la classe métier, et celle de la classe tierce, des précédents exemples :

// (...)
/**
 * A car business object example
 *
 * @after_commit afterCommitCar
 * @after_commit After_Commit_Class::afterCommitCar
 */
class Car
// (...)

Les traitements des deux méthodes étant appelés, les deux textes vont s’afficher dans l’ordre :

Doing things inside Car
Doing things outside Car

Interruption de la chaîne d’appels

• false : l’exécution est interrompue
• toute autre valeur (y compris null ou toute valeur vide autre que false ) : l’exécution se poursuit

Exemple : on réécrit la méthode afterCommitCar de la classe métier Car , qui sera la première exécutée dans notre exemple précédent :

	/**
	 * @param $link    Data_Link
	 * @param $options Option[]
	 * @return boolean
	 */
	public function afterCommitCar(Data_Link $link, $options)
	{
		// Do what you have to do after each write of a car here
		echo 'Doing things inside Car only' . BR;
		return false;
	}

Seul le traitement de cette méthode sera appelé, le seul texte affiché sera donc :

Doing things inside Car only

Voir aussi

• Utiliser les événements du framework
• @before_write – Événement déclenché avant l’écriture
• @after_write – Événement déclenché après l’écriture