Reflection in PHP

Definition:
In der Programmierung bedeutet Reflexion (engl. reflection) oder Introspektion, dass ein Programm seine eigene Struktur kennt und diese, wenn nötig, modifizieren kann.

Gibt es seit PHP 5.

1.) ReflectionClass — The ReflectionClass class => Class Reflection

  • ReflectionClass::getConstants — Gets constants
  • ReflectionClass::getConstructor — Gets constructor
  • ReflectionClass::getDocComment — Gets doc comments
  • ReflectionClass::getFileName — Gets the filename of the file in which the class has been defined
  • ReflectionClass::getInterfaces — Gets the interfaces
  • ReflectionClass::getMethods — Gets a list of methods
  • ReflectionClass::getParentClass — Gets parent class
  • ReflectionClass::getProperties — Gets properties
  • ReflectionClass::getStartLine — Gets starting line number
  • ReflectionClass::getStaticProperties — Gets static properties
  • ReflectionClass::implementsInterface — Implements interface
  • ReflectionClass::inNamespace — Checks if in namespace
  • ReflectionClass::isAbstract — Checks if class is abstract
  • ReflectionClass::isFinal — Checks if class is final
  • ReflectionClass::isInstance — Checks class for instance
  • ReflectionClass::isInstantiable — Checks if instantiable
  • ReflectionClass::isInterface — Checks if interface
  • ReflectionClass::isSubclassOf — Checks if a subclass
  • ReflectionClass::isUserDefined — Checks if user defined
  • ReflectionClass::newInstance — Creates a new class instance from given arguments.

2.) ReflectionExtension — The ReflectionExtension class => PHP Extension Reflection

  • ReflectionExtension::getClasses — Gets classes
  • ReflectionExtension::getVersion — Gets extension version
  • ReflectionExtension::info — Gets extension info

3.) ReflectionFunction — The ReflectionFunction class => Function Reflection

  • ReflectionFunction::invoke — Invokes function

4.) ReflectionMethod — The ReflectionMethod class => Method Reflection

  • ReflectionMethod::getDeclaringClass — Gets declaring class for the reflected method.
  • ReflectionMethod::invoke — Invoke
  • ReflectionMethod::isAbstract — Checks if method is abstract
  • ReflectionMethod::isConstructor — Checks if method is a constructor
  • ReflectionMethod::isDestructor — Checks if method is a destructor
  • ReflectionMethod::isFinal — Checks if method is final
  • ReflectionMethod::isPrivate — Checks if method is private
  • ReflectionMethod::isProtected — Checks if method is protected
  • ReflectionMethod::isPublic — Checks if method is public
  • ReflectionMethod::isStatic — Checks if method is static

5.) ReflectionParameter — The ReflectionParameter class => Parameter Reflection

  • ReflectionParameter::getName — Gets parameter name
  • ReflectionParameter::isArray — Checks if parameter expects an array
  • ReflectionParameter::isDefaultValueAvailable — Checks if a default value is available
  • ReflectionParameter::isOptional — Checks if optional
  • ReflectionParameter::isPassedByReference — Checks if passed by reference

6.) ReflectionProperty — The ReflectionProperty class => Property Reflection

  • ReflectionProperty::getDocComment — Gets doc comment
  • ReflectionProperty::getName — Gets property name
  • ReflectionProperty::isPrivate — Checks if property is private
  • ReflectionProperty::isProtected — Checks if property is protected
  • ReflectionProperty::isPublic — Checks if property is public
  • ReflectionProperty::isStatic — Checks if property is static
  • ReflectionProperty::setValue — Set property value

Zend bietet noch ein Abstraktionslayer dafür an.
Z.B. Direkt alle Methoden als Reflection-Objects und nicht als String zu bekommen.

Es lassen sich z.B. Properties befüllen.

Beispiel für die Verwendung:
[code]
getConstants())) {
throw new Facebook_Exception(‚Type of Object is incorrect‘);
}

$className = ‚Facebook_Object_‘ . $type;

if (!class_exists($className)) {
throw new Facebook_Exception(‚Class „‚ . $className . ‚“ could not be instantiated.‘);
}

return new $className($data);
}
}
[/code]

GD Star Rating
loading...

Restful

Während der Schulung ging es unter anderem auch um REST-Webservices und dass die doch wirklich „restful“ sein sollten, also Http-Status-Codes zurück liefern, nur die Method (Get, Put, Post, Delete), welche auch passend ist akzeptieren sollen, …

Ich habe das bis jetzt immer sehr lax. Also es gibt ne 404 von ZF, wenn der Service nicht da ist, aber ansonsten immer ne 200 und den Fehler dann als Message im Body der Response. Auch benutze ich meistens Get und sonst nichts. Wie handhabt ihr das, wenn ihr Rest-Services in PHP schreibt?

Darüber hinaus würde mich interessieren, was ihr so von nem Webservice zurück geben lasst. XML? Json? Und wie ihr das macht, wenn ihr Zend Framework benutzt. Generiert ihr ein eigenes XML oder habt ihr nen schönen Trick auf Lager?

GD Star Rating
loading...

Radikales Cachen

Was soll man denn nur cachen? Datenbankabfragen? Webservice-Calls? Die Frage habe ich mir glaub schon 100 Mal gestellt.
Mittlerweile bin ich ja der Meinung: Html. Also am besten man cached das komplette Html einer Webseite und gibt das einfach aus. Ja, alles was veränderlich ist (z.B. User eingeloggt), muss dann eben per AJAX aktualisiert werden.
Ich habe das ganze Mithilfe eines Controller-Plugins gelöst, dass, wenn es einen Cache-Eintrag findet, diesen ausgibt und dir Verarbeitung des Skriptes sofort stoppt via exit. Ist leider momentan aufgrund der Architektur des Frontcontrollers nicht anders möglich, zumindest nicht zu diesem frühen Zeitpunkt (vor dem Routing).
Man muss bei dieser Vorgehensweise natürlich wissen, dass natürlich kein weiterer PHP-Code ausgeführt wird. Also kein Tracking oder so.
Dafür ist es verdammt schnell. 😉

[code]
_cache instanceof \Zend_Cache_Core
&& $request instanceof \Zend_Controller_Request_Http
&& $request->isGet()
) {
$cacheEntry = $this->_cache->load(
$this->_getCacheKey(
$request->getRequestUri()));

// check if cache entry is response http object
if ($cacheEntry instanceof \Zend_Controller_Response_Http) {
$cacheEntry->sendResponse();
exit();
}
}

}

/**
* check if to use cache and write to cache if needed
*
* @throws Exception
*/
public function dispatchLoopShutdown() {
// check if to cache
if ($this->_cache instanceof \Zend_Cache_Core) {

// check if config is not set
if (!($this->_config instanceof \Zend_Config)) {
throw new Exception(‚Config has to be set‘);
}

// check against config if to cache
$request = $this->getRequest();
$module = $request->getModuleName();
$controller = $request->getControllerName();
$action = $request->getActionName();

if ($this->_config->__isset($module)
&& $this->_config->get($module)->__isset($controller)
&& $this->_config->get($module)->get($controller)->__isset($action)
) {
$this->_cache->save(
$this->getResponse(),
$this->_getCacheKey(
$request->getRequestUri()));
}
}
}

/* HELPER METHODS */
/**
* generate cache key
*
* @param string $rawCacheKey
* @return string
*/
private function _getCacheKey($rawCacheKey) {
return preg_replace(‚/[^a-zA-Z0-9_]/‘, ‚_‘, $rawCacheKey);
}

/* GETTER AND SETTER */
/**
* get cache
*
* @return \Zend_Cache_Core
*/
public function getCache()
{
return $this->_cache;
}
/**
* set cache
*
* @param \Zend_Cache_Core $cache
*/
public function setCache(\Zend_Cache_Core $cache)
{
$this->_cache = $cache;
}

/**
* get the config
*
* @return \Zend_Config
*/
public function getConfig()
{
return $this->_config;
}
/**
* set config
*
* @param \Zend_Config $config
*/
public function setConfig(\Zend_Config $config)
{
$this->_config = $config;
}

}
[/code]

GD Star Rating
loading...