Aspect4Delphi
1.0.4
L'aspect4delphi se compose d'une bibliothèque qui permet l'utilisation du concept de programmation orientée vers l'aspect (AOP) à Delphi.
AOP est un paradigme de programmation qui vise à augmenter la modularité en permettant la séparation des préoccupations croisées. Il le fait en ajoutant un comportement supplémentaire au code existant sans modification du code lui-même. Au lieu de cela, nous pouvons déclarer ce nouveau code et ces nouveaux comportements séparément.
Aspect4Delphi nous aide à mettre en œuvre ces préoccupations croisées.
Pour obtenir une copie locale en cours, suivez ces étapes simples.
Pour utiliser cette bibliothèque, une version mise à jour de Delphi IDE (XE ou supérieur) est requise.
Cloner le repo
git clone https://github.com/ezequieljuliano/Aspect4Delphi.git
Ajoutez le "chemin de recherche" de votre IDE ou de votre projet les répertoires suivants:
Aspect4Delphisrc
Pour fournir le paradigme d'orientation de l'aspect dans votre projet avec Aspect4Delphi dont vous avez besoin:
Pour illustrer l'utilisation, examinons une solution pour gérer les journaux d'une application.
Implémentez un attribut Pointcut (hérite de préférence de AspectAttribute):
interface
uses
Aspect.Core;
type
LoggingAttribute = class(AspectAttribute)
private
{ private declarations }
protected
{ protected declarations }
public
{ public declarations }
end;
implementation
end.
Implémenter la classe qui représente votre aspect et contient les méthodes de conseils (vous devez implémenter l'interface Iaspect):
interface
uses
System.SysUtils,
System.Rtti,
Aspect,
Aspect.Core,
Logging.Attribute,
App.Context;
type
ELoggingAspectException = class(Exception)
private
{ private declarations }
protected
{ protected declarations }
public
{ public declarations }
end;
TLoggingAspect = class(TAspectObject, IAspect)
private
{ private declarations }
protected
procedure OnBefore(
instance: TObject;
method: TRttiMethod;
const args: TArray<TValue>;
out invoke: Boolean;
out result: TValue
); override;
procedure OnAfter(
instance: TObject;
method: TRttiMethod;
const args: TArray<TValue>;
var result: TValue
); override;
procedure OnException(
instance: TObject;
method: TRttiMethod;
const args: TArray<TValue>;
out raiseException: Boolean;
theException: Exception;
out result: TValue
); override;
public
{ public declarations }
end;
implementation
{ TLoggingAspect }
procedure TLoggingAspect.OnAfter(instance: TObject; method: TRttiMethod;
const args: TArray<TValue>; var result: TValue);
var
attribute: TCustomAttribute;
begin
inherited;
for attribute in method.GetAttributes do
if attribute is LoggingAttribute then
begin
LoggingFile.Add('After the execution of ' +
instance.QualifiedClassName + ' - ' +
method.Name
);
Break;
end;
end;
procedure TLoggingAspect.OnBefore(instance: TObject; method: TRttiMethod;
const args: TArray<TValue>; out invoke: Boolean; out result: TValue);
var
attribute: TCustomAttribute;
begin
inherited;
for attribute in method.GetAttributes do
if attribute is LoggingAttribute then
begin
LoggingFile.Add('Before the execution of ' +
instance.QualifiedClassName + ' - ' +
method.Name
);
Break;
end;
end;
procedure TLoggingAspect.OnException(instance: TObject; method: TRttiMethod;
const args: TArray<TValue>; out raiseException: Boolean;
theException: Exception; out result: TValue);
var
attribute: TCustomAttribute;
begin
inherited;
for attribute in method.GetAttributes do
if attribute is LoggingAttribute then
begin
LoggingFile.Add('Exception in executing ' +
instance.QualifiedClassName + ' - ' +
method.Name + ' - ' +
theException.Message
);
Break;
end;
end;
end.
Enregistrez votre attribut Pointcut et sa classe d'aspect dans son contexte (de préférence garder ce contexte dans l'instance de Singleton):
interface
uses
Logging.Aspect;
Aspect.Context;
function AspectContext: IAspectContext;
implementation
var
AspectContextInstance: IAspectContext = nil;
function AspectContext: IAspectContext;
begin
if (AspectContextInstance = nil) then
begin
AspectContextInstance := TAspectContext.Create;
AspectContextInstance.RegisterAspect(TLoggingAspect.Create);
end;
Result := AspectContextInstance;
end;
end.
Dans votre classe d'entreprise, utilisez l'attribut pour définir vos points de jointure. Vous pouvez utiliser le constructeur et le destructeur pour ajouter votre classe chez le tisserand.
interface
uses
System.SysUtils,
Logging.Attribute,
App.Context;
type
EWhatsAppMessageException = class(Exception)
private
{ private declarations }
protected
{ protected declarations }
public
{ public declarations }
end;
TWhatsAppMessage = class
private
{ private declarations }
protected
{ protected declarations }
public
constructor Create;
destructor Destroy; override;
[Logging]
procedure Send; virtual;
end;
implementation
{ TWhatsAppMessage }
constructor TWhatsAppMessage.Create;
begin
inherited Create;
AspectContext.Weaver.Proxify(Self);
end;
destructor TWhatsAppMessage.Destroy;
begin
AspectContext.Weaver.Unproxify(Self);
inherited Destroy;
end;
procedure TWhatsAppMessage.Send;
begin
//Execution of send.
end;
Voir les problèmes ouverts pour une liste des fonctionnalités proposées (et des problèmes connus).
Les contributions font de la communauté open source un endroit aussi incroyable pour apprendre, inspirer et créer. Toutes les contributions que vous faites sont grandement appréciées .
git checkout -b feature/AmazingFeature )git commit -m 'Add some AmazingFeature' )git push origin feature/AmazingFeature ) Distribué sous la licence Apache. Voir LICENSE pour plus d'informations.
Pour nous contacter, utilisez les options:
https://github.com/ezequieljuliano/aspect4delphi
