Thread Techniken für Plugin-Einbindung (3 answers)
Opened by marky at 2011-09-24 12:58

marky
 2011-09-27 10:12
#152703 #152703
User since
2003-08-15
215 Artikel
BenutzerIn
[Homepage] [default_avatar]
Hallo,

ich mache das ganz anders, die Hooks über die Signale könnte man noch ändern, das muss ich mal anschauen, wie man das am besten implementiert, die Tempalte-Plugins laufen so

Code: (dl )
1
2
3
4
5
6
7
8
9
10
11
12
while ( $tmpl_line  =~ /\[OS_TMPLPLUGIN:(\w+):(\w+):(.*?)\]/g ) {

my ($tpath,$tfunc,$tfval,$tpvalue) = ($1,$2,$3,'') ;
if ( -e "pfad/Tmpl/$tpath/$tfunc.pm" ) {

eval "require Tmpl::$tpath\::$tfunc" ;
die "Fehler bei Einbindung Template-Plugin : Tmpl::$tpath\::$tfunc : $@\n" if ($@) ;

my $tplg = $tfunc->new(\%CONFIG,\%PARA,$tfval);
$tpvalue = $tplg->out ;
}


dann muss man nicht den Code evaluieren. Und die Plugins an sich sehen alles gleich aus vom Aufbau.

Das andere habe ich jetzt noch etwas anders gelöst und zwar über AUTOLOAD, meine Frage dabei ist jetzt, dass man immer liest, dass AUTOLOAD teuer ist - ist das aber immer noch so - in der jetztigen Lösung würden quasi die Funktionen immer über AUTOLOAD laufen.

Siehst Du ein Problem, was die Performance angeht? Die Lösung ist nämlich wirlich genial. Ist nur ein bisschen viel zum Posten, aber jetzt gibt es die Möglichkeit, ein Plugin vor und nach der Funktion auszuführen und die Funktion selber zu überschreiben.

Hier mal das Autoload

Code: (dl )
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
sub AUTOLOAD {

my ($self,$arg1) = @_ ;

my @func = split(/\:\:/,$AUTOLOAD) ;
my $f = $func[-1] ;
my $fb = $f . "_beforeEvent" ;
my $fa = $f . "_afterEvent" ;
my $fo = $f . "_overEvent" ;

print "FUNC : @func ($func[-1]) \n" ;
print "Obj : " , $self->{'modclass'} , " ( $self->{'modobj'} ) \n" ;
print "AUTOL : $AUTOLOAD | @_ \n\n" ;


###
#Ausgabe vorher

if ( $self->{'plugclass'}->can($fb) ) {

print "Methode $self -> $fb vorhanden\n" ;
$self->{'plugclass'}->($f . "_beforeEvent")($arg1) ;
}

###
#Eigentliche Funktion

if ( $self->{'plugclass'}->can($fo) ) {

print "Ausgabe OVERfunktion\n" ;
$self->{'plugclass'}->$fo($arg1) ;

} elsif ( $self->{'modobj'} && $func[-1] ) {

print "Ausgabe Standardfunktion\n" ;
$self->{'modobj'}->$f($arg1) ;
}

###
#Ausgabe nachher

if ( $self->{'plugclass'}->can($fa) ) {

print "Methode $self -> $fa vorhanden\n" ;
$self->{'plugclass'}->$fa($arg1) ;

}
print "\n-----------\n\n" ;

}

sub DESTROY {}

1 ;

Aufruf wäre so

my $pobj = Plugin->new('TestClass','TestClassPlug') ;
$pobj->t1('T1T1T1') ;
$pobj->t2('T2T2T2') ;


Das ist mal wirklich eine sehr sehr flexible Lösung, aber halt mit AUTOLOAD erkauft, die alternative wäre nur, dass man eine exec-Funktion macht, dann muss aber jede Funktion über die exec aufrufen, was vom Code her nicht so transparent aussehen würde, anstelle von

$pobj->t1('T1T1T1') ;

dann

$pobj->exec('t1','T1T1T1') ;

und man könnte auf das AUTOLOAD verzichten, das scheint mir aber ein bisschen exotisch zu sein.


Gruss Marky

View full thread Techniken für Plugin-Einbindung