Go! AOP is a modern aspect-oriented framework in plain PHP with rich features for the new level of software development. The framework allows cross-cutting issues to be solved in the traditional object-oriented PHP code by providing a highly efficient and transparent hook system for your exisiting code.
- Provides dynamic hook system for PHP without changes in the original source code.
- Doesn't require any PECL-extentions (php-aop, runkit, uopz) and DI-containers to work.
- Object-oriented design of aspects, joinpoints and pointcuts.
- Intercepting an execution of any public or protected method in a classes.
- Intercepting an execution of static methods and methods in final classes.
- Intercepting an execution of methods in the traits.
- Intercepting an access to the public/protected properties for objects.
- Hooks for static class initialization (after class is loaded into PHP memory).
- Hooks for object initialization (intercepting
newkeywords). - Intercepting an invocation of system PHP functions.
- Ability to change the return value of any methods/functions via
Aroundtype of advice. - Rich pointcut grammar syntax for defining pointcuts in the source code.
- Native debugging for AOP with XDebug. The code with weaved aspects is fully readable and native. You can put a breakpoint in the original class or in the aspect and it will work (for debug mode)!
- Can be integrated with any existing PHP frameworks and libraries (with or without additional configuration).
- Highly optimized for production use: support of opcode cachers, lazy loading of advices and aspects, joinpoints caching, no runtime checks of pointcuts, no runtime annotations parsing, no evals and
__callmethods, no slow proxies andcall_user_func_array(). Fast bootstraping process (2-20ms) and advice invocation.
AOP (Aspect-Oriented Programming) is an approach to cross-cutting concerns, where these concerns are designed and implemented in a "modular" way (that is, with appropriate encapsulation, lack of duplication, etc.), then integrated into all the relevant execution points in a succinct and robust way, e.g. through declarative or programmatic means.
In AOP terms, the execution points are called join points. A set of those points is called a pointcut and the new behavior that is executed before, after, or "around" a join point is called advice. You can read more about AOP in Introduction section.
Go! AOP framework can be installed with composer. Installation is quite easy:
- Download the framework using composer
- Create an application aspect kernel
- Configure the aspect kernel in the front controller
- Create an aspect
- Register the aspect in the aspect kernel
Ask composer to create new project in empty directory:
composer create-project goaop/frameworkAfter that just configure your web server to demos/ folder and open it in your browser. Then you can look at some demo examples before going deeper into installing it in your project.
Ask composer to download the latest version of Go! AOP framework with its dependencies by running the command:
composer require goaop/frameworkComposer will install the framework to your project's vendor/goaop/framework directory.
The aim of this framework is to provide easy AOP integration for your application.
You have to first create the AspectKernel class
for your application. This class will manage all aspects of your
application in one place.
The framework provides base class to make it easier to create your own kernel.
To create your application kernel, extend the abstract class Go\Core\AspectKernel
<?php
// app/ApplicationAspectKernel.php
use Go\Core\AspectKernel;
use Go\Core\AspectContainer;
/**
* Application Aspect Kernel
*/
class ApplicationAspectKernel extends AspectKernel
{
/**
* Configure an AspectContainer with advisors, aspects and pointcuts
*
* @param AspectContainer $container
*
* @return void
*/
protected function configureAop(AspectContainer $container)
{
}
}To configure the aspect kernel, call init() method of kernel instance.
// front-controller, for Symfony2 application it's web/app_dev.php
include __DIR__ . '/vendor/autoload.php'; // use composer
// Initialize an application aspect container
$applicationAspectKernel = ApplicationAspectKernel::getInstance();
$applicationAspectKernel->init([
'debug' => true, // use 'false' for production mode
'appDir' => __DIR__ . '/..', // Application root directory
'cacheDir' => __DIR__ . '/path/to/cache/for/aop', // Cache directory
// Include paths restricts the directories where aspects should be applied, or empty for all source files
'includePaths' => [
__DIR__ . '/../src/'
]
]);Aspect is the key element of AOP philosophy. Go! AOP framework just uses simple PHP classes for declaring aspects, which makes it possible to use all features of OOP for aspect classes. As an example let's intercept all the methods and display their names:
// Aspect/MonitorAspect.php
namespace Aspect;
use Go\Aop\Aspect;
use Go\Aop\Intercept\FieldAccess;
use Go\Aop\Intercept\MethodInvocation;
use Go\Lang\Annotation\After;
use Go\Lang\Annotation\Before;
use Go\Lang\Annotation\Around;
use Go\Lang\Annotation\Pointcut;
/**
* Monitor aspect
*/
class MonitorAspect implements Aspect
{
/**
* Method that will be called before real method
*
* @param MethodInvocation $invocation Invocation
* @Before("execution(public Example->*(*))")
*/
public function beforeMethodExecution(MethodInvocation $invocation)
{
$obj = $invocation->getThis();
echo 'Calling Before Interceptor for method: ',
is_object($obj) ? get_class($obj) : $obj,
$invocation->getMethod()->isStatic() ? '::' : '->',
$invocation->getMethod()->getName(),
'()',
' with arguments: ',
json_encode($invocation->getArguments()),
"<br>\n";
}
}Easy, isn't it? We declared here that we want to install a hook before the execution of
all dynamic public methods in the class Example. This is done with the help of annotation
@Before("execution(public Example->*(*))")
Hooks can be of any types, you will see them later.
But we don't change any code in the class Example! I can feel your astonishment now.
To register the aspect just add an instance of it in the configureAop() method of the kernel:
// app/ApplicationAspectKernel.php
use Aspect\MonitorAspect;
//...
protected function configureAop(AspectContainer $container)
{
$container->registerAspect(new MonitorAspect());
}
//...Now you are ready to use the power of aspects! Feel free to change anything everywhere. If you like this project, you could support it 
By default, Go! AOP uses Doctrine\Common\Cache\FilesystemCache for caching
annotations. However, if you need to use any other caching engine
for annotation, you may configure cache driver via annotationCache configuration
option of your application aspect kernel. Only requirement is
that cache driver implements Doctrine\Common\Cache\Cache interface.
This can be very useful when deploying to read-only filesystems. In that
case, you may use, per example, Doctrine\Common\Cache\ArrayCache or some
memory-based cache driver.
Weaving Doctrine entities can not be supported out of the box due to the fact that Go! AOP generates two sets of classes for each weaved entity, a concrete class and proxy with pointcuts. Doctrine will interpret both of those classes as concrete entities and assign for both of them same metadata, which would mess up the database and relations (see goaop#327).
Therefore, a workaround is provided with this library which will sort out
mapping issue in Doctrine. Workaround is in form of event subscriber,
Go\Bridge\Doctrine\MetadataLoadInterceptor which has to be registered
when Doctrine is bootstraped in your project. For details how to do that,
see http://docs.doctrine-project.org/projects/doctrine-orm/en/latest/reference/events.html.
Event subscriber will modify metadata entity definition for generated Go! Aop proxies as mapped superclass. That would sort out issues on which you may stumble upon when weaving Doctrine entities.
To contribute changes see the Contribute Readme
Documentation about Go! library can be found at official site.