goaop / framework
Framework for aspect-oriented programming in PHP.
Fund package maintenance!
lisachenko
Installs: 3 645 051
Dependents: 38
Suggesters: 2
Security: 0
Stars: 1 659
Watchers: 86
Forks: 163
Open Issues: 11
Requires
- php: ^7.4.0
- doctrine/annotations: ^1.11.1
- doctrine/cache: ^1.10
- goaop/parser-reflection: ^3.0.1
- jakubledl/dissect: ~1.0
- laminas/laminas-code: ^4.0
- symfony/finder: ^4.4|^5.1
Requires (Dev)
- adlawson/vfs: ^0.12.1
- doctrine/orm: ^2.5
- phpstan/phpstan: ^0.12.64
- phpunit/phpunit: ^9.5
- symfony/console: ^4.4|^5.1
- symfony/filesystem: ^4.4|^5.1
- symfony/process: ^4.4|^5.1
- webmozart/glob: ^4.1
Suggests
- symfony/console: Enables the usage of the command-line tool.
- dev-master / 4.0.x-dev
- 3.x-dev
- 3.0.0
- 3.0.0-RC2
- 3.0.0-RC1
- 2.x-dev
- 2.3.5
- 2.3.4
- 2.3.3
- 2.3.2
- 2.3.1
- 2.3.0
- 2.2.0
- 2.1.2
- 2.1.1
- 2.1.0
- 2.0.0
- 2.0.0-alpha.1
- 1.x-dev
- 1.2.1
- 1.2.0
- 1.1.1
- 1.1.0
- 1.0.2
- 1.0.1
- 1.0.0
- 1.0.0-alpha.2
- 1.0.0-alpha.1
- 0.x-dev
- 0.6.1
- 0.6.0
- 0.5.0
- 0.5.0-RC1
- 0.4.3
- 0.4.2
- 0.4.1
- 0.4.0
- 0.3.0
- 0.2.0
- 0.1.1
- 0.1.0
- dev-bug/generated-method-attributes
- dev-dependabot/composer/doctrine/orm-tw-2.5or-tw-3.0
- dev-dependabot/composer/phpunit/phpunit-tw-10.5.10or-tw-11.0.0
- dev-samsonasik-patch-1
- dev-feature/composer-class-map
This package is auto-updated.
Last update: 2024-10-07 13:25:56 UTC
README
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.
Features
- 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
new
keywords). - Intercepting an invocation of system PHP functions.
- Ability to change the return value of any methods/functions via
Around
type 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
__call
methods, no slow proxies andcall_user_func_array()
. Fast bootstraping process (2-20ms) and advice invocation.
What is AOP?
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.
Installation
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
Step 0 (optional): Try demo examples in the framework
Ask composer to create new project in empty directory:
composer create-project goaop/framework
After 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.
Step 1: Download the library using composer
Ask composer to download the latest version of Go! AOP framework with its dependencies by running the command:
composer require goaop/framework
Composer will install the framework to your project's vendor/goaop/framework
directory.
Step 2: Create an application aspect kernel
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) { } }
3. Configure the aspect kernel in the front controller
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/' ] ]);
4. Create an aspect
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) { echo 'Calling Before Interceptor for: ', $invocation, ' 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.
5. Register the aspect in the aspect kernel
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()); } //...
6. Optional configurations
6.1 Custom annotation cache
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.
6.2 Support for weaving Doctrine entities (experimental, alpha)
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 #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.
7. Contribution
To contribute changes see the Contribute Readme
Documentation
Documentation about Go! library can be found at official site. If you like this project, you could support it via