Blog - Hannes Pries - Webdeveloper Blog - Entwicklung mit Shopware, PHP, HTML5 und JavaScript

Shopware: Legacy-Plugin Service dekorieren

Gehen wir mal davon aus wir hätten noch ein Legacy-Plugin mit einer Bootstrap-php, die einen Service registriert, den wir dekorieren wollen. Über die services.xml geht so etwas nicht.

class HprTest extends Plugin{
public static function getSubscribedEvents(){
return [
'Enlight_Bootstrap_AfterInitResource_hpr_legacy.the_service' => 'decorateService',
];
}

public function decorateService()
{
$coreService = Shopware()->Container()->get('hpr_legacy.the_service');
$refl = new \ReflectionClass(get_class($coreService));

$field = $refl->getProperty('config');
$field->setAccessible(true);
$config = $field->getValue($coreService);

$service = new TheNewService($config);
Shopware()->Container()->set('hpr_legacy.the_service', $service;
}
}

Sehr sehr unschön.. aber es funktioniert so. Der Weg über die XML ist natürlich sehr viel schöner, gerade weil die Injection der Constructor Arguments vom ursprünglichen Service übernommen werden man nicht diese per Reflections erst einmal wieder aus dem ursprünglichen Service heraus gepult werden müssen.

PHP Annotation-based Validator

Mein erster Prototyp für einen Validator in PHP der mit Annotationen arbeitet. Über ReflectionClass kann ich mir dann die Properties holen und dann mit getDocComments() mir die Annotationen auslesen.

<html>
<body>
<?php
$anno="@validate{type:,range:,regex:}";

function validateValue($value,$annotation){
$result=true;
$annotation=preg_replace("/^.*\@validate\{(.+)}.*$/Uis","$1",$annotation);
$parts=preg_split("/,/",$annotation);
foreach($parts as $part){
$check=preg_split("/:/",$part);
$key=$check[0];
if($key=="notnull" && $value==null){
$result=false;
}
else if($key=='type'){
$condition=$check[1];
if($condition=='int' && !is_int($value)){
$result=false;
}
else if($condition=='float' && !is_float($value)){
$result=false;
}
else if($condition=='array' && !is_array($value)){
$result=false;
}
}
else if($key=='regex'){
$result=preg_match($check[1],$value);
}
else if($key=='range'){
$range=preg_split("/~/",$check[1]);
if($value>$range[1] || $value<$range[0]){
$result=false;
}
}
else if($key=='countrange'){
$range=preg_split("/~/",$check[1]);
if(count($value)>$range[1] || count($value)<$range[0]){
$result=false;
}
}
else if($key=='lengthrange'){
$range=preg_split("/~/",$check[1]);
if(strlen($value)>$range[1] || strlen($value)<$range[0]){
$result=false;
}
}

if(!$result){
return $result;
}
}
return $result;
}

echo "Test notnull(failed): ".validateValue(null,"@validate{notnull}")." ";
echo "Test notnull (ok): ".validateValue("test","@validate{notnull}")." ";
echo "Test regex (failed): ".validateValue("ein komischer test","@validate{regex:/komischerer/}")." ";
echo "Test regex (ok): ".validateValue("ein komischer test","@validate{regex:/komischer/}")." ";
echo "Test type (failed): ".validateValue("test","@validate{type:array}")." ";
echo "Test type (ok): ".validateValue(array("1","2"),"@validate{type:array}")." ";
echo "Test range (failed): ".validateValue(3,"@validate{range:4~12}")." ";
echo "Test range (ok): ".validateValue(6,"@validate{range:4~12}")." ";
echo "Test lengthrange (failed): ".validateValue("123","@validate{lengthrange:4~12}")." ";
echo "Test lengthrange (ok): ".validateValue("123456","@validate{lengthrange:4~12}")." ";
?>
</body>
</html>

PHP Annotations und Reflections

Mit Hilfe der Reflections-Klassen in PHP sit es auch z.B. möglich sich einen JSON-Encoder zubauen, der nicht verlangt, dass alle Attribute der Klasse public sein müssen. Ähnlich wie in Java kann man hier auch auf private Attribute ohne Probleme zugreifen wenn man dieses setzt:

$prop->setAccessible(true);

Wenn man dann noch neben den skalaren Typen eine extra Behandlung für Array-Inhalte und Objekte einbaut, kann man sich ganz einfach einen rekursiven JSON-Encoder bauen, der auch mit normalen Beans mit Gettern und Settern zurecht kommt und man keine zusätzlichen DTOs mehr extra anlegen muss.

class XWJSONConverter{
public function __construct(){

}

public function convert($value,$level=0,$name=null,$firstInLine=true,$result=""){
$opening=false;
if($level==0 && $name!=null){
$result.="{";
$opening=true;
}
if(is_scalar($value)){
if(!$firstInLine){
$result.= ",";
}
if($name!=null){
$result.= '"'.$name.'":';
}
$result.= json_encode($value);
}
else if(is_array($value)){
if($name!=null){
$result.= '"'.$name.'":';
}
$result.= "[";
$i=0;
foreach($value as $val){
$result=$this->convert($val,$level+1,null,$i==0,$result);
$i++;
}
$result.= "]";
}
else if(is_object($value)){
if(!$firstInLine){
$result.= ",";
}
if($name!=null){
$result.= '"'.$name.'":';
}
$result.= "{";
$ref=new ReflectionClass(get_class($value));
$props=$ref->getProperties();
$cnt=count($props);
for($i=0;$i<$cnt;$i++){
$prop=$props[$i];

$doc=trim($prop->getDocComment());
if(!preg_match("/@json_transient/i",$doc)){
$prop->setAccessible(true);
$name=$prop->getName();
if($prop->isPrivate() || $prop->isProtected()){
$name=preg_replace("/^_/","",$name);
}
$result=$this->convert($prop->getValue($value),$level+1,$name,$i==0,$result);
}
}
$result.= "}";
}
else if(is_null($value)){
if (!$firstInLine) {
$result .= ',';
}
if ($name != null) {
$result .= '"' . $name . '":';
}
$result .= 'null';
}

if($opening){
$result.="}";
}
return $result;
}
}

Ein Decoder war mir jetzt nciht wirklich wichtig, da in meinen Anwendungsfällen PHP eigetnlich immer nur JSON für REST-APIs generiert und auf JavaScript-Seite, das decodieren in eine Objekt-Struktur ohne Probleme dann wieder möglich ist. Da sind private und public nicht mehr wichtig.

Was hier noch interessant sein könnte ist mein Versuch mit Annotations in PHP zu arbeiten. Wenn man verhindern will, dass ein Attribute mit nach JSON encodiert wird, kann man das damit verhindern:

class Test{
private $toJSON="ok";
/**
* @json_transient
*/
private $notToJSON="ne";
}

Damit wird im JSON-String nur das erste Attribute auftauchen.

Hannes Pries - Web/Shopware/JavaScript-Developer BlogWeil es immer eine simple Lösung gibt!

Hannes Pries - Web/Shopware/JavaScript-Developer Blog
Weil es immer eine simple Lösung gibt!