TypeORM - Écouteur d'entité et journalisation

L'écouteur d'entité est utilisé dans les entités qui prennent en charge la méthode personnalisée et écoutent des événements spécifiques. Nous pouvons définir n'importe quelle méthode personnalisée d'entité à l'aide de décorateurs. Comprenons les décorateurs en bref.

@AfterLoad - Lorsque l'entité est chargée à l'aide de QueryBuilder ou du référentiel / gestionnaire, cette méthode sera appelée.
@BeforeInsert - Cette méthode sera appelée avant l'insertion de l'entité à l'aide du référentiel / gestionnaire.
@AfterInsert - Cette méthode sera appelée après l'insertion de l'entité à l'aide du référentiel / gestionnaire.
@BeforeUpdate - Cette méthode l'appellera avant qu'une entité existante ne soit mise à jour à l'aide du référentiel / gestionnaire.
@AfterUpdate - Il appellera après la mise à jour d'une entité.
@BeforeRemove - Il appellera avant qu'une entité soit supprimée.
@AfterRemove - Il appellera après la suppression d'une entité.

Abonné

L'abonné est utilisé pour écouter des événements d'entité spécifiques. Il est mis en œuvre à partir deEntitySubscriberInterface. Comprenons un exemple simple d'utilisation de l'écouteur d'entité dans l'abonné. Considérez que l'entité Student est illustrée ci-dessous -

Student.ts

import {Entity, PrimaryGeneratedColumn, Column} from "typeorm"; 

@Entity() 
export class Student {     

   @PrimaryGeneratedColumn() 
   id: number; 
   
   @Column() 
   Name: string; 
   
   @Column() 
   age: number; 
}

Créer un abonné étudiant

L'abonné est créé à l'aide de la commande ci-dessous -

typeorm subscriber:create -n StudentSubscriber

La commande ci-dessus crée un répertoire d'abonnés dans votre projet src. Ensuite, le fichier StudentSubscriber.ts est créé dans votre abonné. Vous pouvez voir la réponse suivante,

Subscriber /Users/workspace/TypeORM/FirstProject/src/subscriber/StudentSubscriber.ts has been created successfully.

Maintenant, passez au fichier, vous pouvez voir le codage ci-dessous -

StudentSubscriber.ts

import {EventSubscriber, EntitySubscriberInterface} from "typeorm"; 

@EventSubscriber() 
export class StudentSubscriber implements EntitySubscriberInterface<any> { 
}

Maintenant, ajoutez les modifications suivantes dans le fichier,

import {EventSubscriber, EntitySubscriberInterface,InsertEvent} from "typeorm"; 
import {Student} from "../entity/Student"; 

@EventSubscriber() 
export class StudentSubscriber implements EntitySubscriberInterface<any> { 
   listenTo() 
   { 
      return Student; 
   } 
   
   afterInsert(event: InsertEvent<Student>) { 
      console.log(event); 
   } 
}

Ici,

Nous avons utilisé afterInsert()méthode pour appeler l'événement d'entité. De même, vous pouvez également utiliser d'autres événements. Nous avons déjà configuré le fichier ormconfig.json. Maintenant, ajoutez les modifications ci-dessous dansindex.ts fichier comme suit -

index.ts

import "reflect-metadata"; import {createConnection} from "typeorm"; import {Student} from "./entity/Student"; 

createConnection().then(async connection => {

   console.log('connection established'); 
}).catch(error => console.log(error));

Après avoir exécuté l'application, vous pouvez voir la sortie ci-dessous sur votre écran,

Enregistrement

La journalisation de la base de données est une partie importante de la conception de votre solution de base de données hautement disponible, car les journaux de base de données permettent de récupérer après une panne et ils permettent de synchroniser les bases de données primaires et secondaires.

Toutes les bases de données sont associées à des journaux. Ces journaux conservent des enregistrements des modifications de la base de données. Si une base de données doit être restaurée à un point au-delà de la dernière sauvegarde complète hors ligne, des journaux sont nécessaires pour transférer les données jusqu'au point de défaillance.

Options de journalisation

La journalisation est activée en ajoutant {logging: true} dans la connexion à la base de données. Les options de journalisation sont classées en différents types. Ils sont les suivants -

query- renvoie toutes les requêtes de journal. Il est défini comme indiqué ci-dessous -

{ 
   host: "localhost",
   ... 
   logging: ["query"] 
}

error- renvoyer les journaux pour toutes les requêtes et erreurs ayant échoué. Il est défini ci-dessous -

{ 
   host: "localhost",
   ... 
   logging: ["error"] 
}

schema - renvoyer les journaux pour le schéma.

warn - renvoyer des avertissements ORM internes.

info - retourne les journaux des messages informatifs ORM internes.

log - renvoyer les messages internes du journal ORM.

Enregistreur personnalisé

La journalisation personnalisée est une option de journalisation simple et hautement personnalisable. Nous pouvons créer notre propre classe de journalisation en utilisant le code ci-dessous -

import {Logger} from "typeorm"; 

export class MyCustomLogger implements Logger { 
   
   // implement all methods from logger class 
}

L'option de connexion est spécifiée dans ormconfig.json comme suit -

name: "mysql", 
type: "mysql", 
host: "localhost", 
port: 3306, 
username: "root", 
password: "root", 
database: "test", 
logger: new MyCustomLogger()

↰ Previous page Next page ↱