update

Author: github-ci

.github/workflows/composer-require-checker.yml

@@ -9,7 +9,6 @@ jobs:
       fail-fast: false
       matrix:
         php_version:
-          - 8.1
           - 8.2
           - 8.3
           - 8.4

.github/workflows/phpunit.yml

@@ -1,24 +1,106 @@
 # AopBundle
 
 [![Latest Version](https://img.shields.io/packagist/v/tourze/symfony-aop-bundle.svg?style=flat-square)](https://packagist.org/packages/tourze/symfony-aop-bundle)
+[![PHP Version](https://img.shields.io/packagist/php-v/tourze/symfony-aop-bundle.svg?style=flat-square)](https://packagist.org/packages/tourze/symfony-aop-bundle)
+[![License](https://img.shields.io/packagist/l/tourze/symfony-aop-bundle.svg?style=flat-square)](https://packagist.org/packages/tourze/symfony-aop-bundle)
+[![Build Status](https://img.shields.io/github/actions/workflow/status/tourze/php-monorepo/ci.yml?style=flat-square)](https://github.com/tourze/php-monorepo/actions)
+[![Coverage](https://img.shields.io/codecov/c/github/tourze/php-monorepo?style=flat-square)](https://codecov.io/gh/tourze/php-monorepo)
 
 [English](README.md) | [中文](README.zh-CN.md)
 
+## Table of Contents
+
+- [Overview](#overview)
+- [Requirements](#requirements)
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Features](#features)
+- [Basic Usage](#basic-usage)
+- [Advanced Usage](#advanced-usage)
+- [Performance Monitoring](#performance-monitoring)
+- [Best Practices](#best-practices)
+- [Configuration](#configuration)
+- [Contributing](#contributing)
+- [License](#license)
+
 ## Overview
 
-AopBundle is a Symfony bundle that implements Aspect-Oriented Programming (AOP) using PHP 8's Attribute features. It enables adding cross-cutting concerns (like logging, caching, transactions) to your code without modifying the core logic.
+AopBundle is a Symfony bundle that implements Aspect-Oriented Programming (AOP) using PHP 8's 
+Attribute features. It enables adding cross-cutting concerns (like logging, caching, transactions) 
+to your code without modifying the core logic.
 
 ## Requirements
 
 - PHP 8.1+
-- Symfony 6.4+
+- Symfony 7.3+
 
 ## Installation
 
 ```bash
 composer require tourze/symfony-aop-bundle
 ```
 
+## Quick Start
+
+### Step 1: Install the Bundle
+
+```bash
+composer require tourze/symfony-aop-bundle
+```
+
+### Step 2: Create a Simple Aspect
+
+Create a logging aspect in `src/Aspect/LoggingAspect.php`:
+
+```php
+<?php
+
+namespace App\Aspect;
+
+use Psr\Log\LoggerInterface;
+use Tourze\Symfony\Aop\Attribute\Aspect;
+use Tourze\Symfony\Aop\Attribute\Before;
+use Tourze\Symfony\Aop\Model\JoinPoint;
+
+#[Aspect]
+class LoggingAspect
+{
+    public function __construct(
+        private LoggerInterface $logger
+    ) {}
+
+    #[Before(serviceTags: ['app.loggable'])]
+    public function logMethodExecution(JoinPoint $joinPoint): void
+    {
+        $this->logger->info('Method executed', [
+            'class' => $joinPoint->getInstance()::class,
+            'method' => $joinPoint->getMethod(),
+            'params' => $joinPoint->getParams(),
+        ]);
+    }
+}
+```
+
+### Step 3: Tag Your Services
+
+Tag services you want to log in `config/services.yaml`:
+
+```yaml
+services:
+    App\Service\UserService:
+        tags:
+            - { name: 'app.loggable' }
+```
+
+### Step 4: Use Your Service
+
+Now when you call methods on `UserService`, they will be automatically logged!
+
+```php
+// This will trigger the logging aspect
+$userService->createUser($userData);
+```
+
 ## Features
 
 - Define aspects using PHP 8 attributes
@@ -30,7 +112,7 @@ composer require tourze/symfony-aop-bundle
 
 ## Basic Usage
 
-### 1. Define an Aspect
+### Define an Aspect
 
 Create a class with the `#[Aspect]` attribute and define advice methods:
 
@@ -54,15 +136,15 @@ class LoggingAspect
 }
 ```
 
-### 2. Available Advice Types
+### Available Advice Types
 
 - `#[Before]` - Executed before the target method
 - `#[After]` - Executed after the target method (regardless of exceptions)
 - `#[AfterReturning]` - Executed after successful method return
 - `#[AfterThrowing]` - Executed when the target method throws an exception
 - `#[CatchException]` - Used for exception handling
 
-### 3. JoinPoint
+### JoinPoint Context
 
 The `JoinPoint` object provides context for the intercepted method:
 
@@ -75,7 +157,7 @@ $joinPoint->getException();    // Exception (for exception advice)
 $joinPoint->proceed();         // Manually execute the original method
 ```
 
-### 4. Pointcut Expressions
+### Pointcut Expressions
 
 Define where advice should be applied:
 
@@ -99,7 +181,60 @@ Define where advice should be applied:
 #[Before('class.getName() === "App\\Service\\UserService"')]
 ```
 
-### 5. Performance Monitoring
+## Advanced Usage
+
+### Exception Handling
+
+Handle exceptions in your aspects:
+
+```php
+#[Aspect]
+class ExceptionHandlingAspect
+{
+    #[AfterThrowing(serviceTags: ['app.monitored'])]
+    public function handleException(JoinPoint $joinPoint): void
+    {
+        $exception = $joinPoint->getException();
+        
+        // Log the exception
+        $this->logger->error('Method failed', [
+            'exception' => $exception->getMessage(),
+            'trace' => $exception->getTraceAsString(),
+        ]);
+        
+        // Optionally transform or suppress the exception
+        if ($exception instanceof RecoverableException) {
+            $joinPoint->setReturnEarly(true);
+            $joinPoint->setReturnValue(null);
+        }
+    }
+}
+```
+
+### Method Interception
+
+Completely control method execution:
+
+```php
+#[Aspect]
+class CacheAspect
+{
+    #[Before(methodAttribute: Cacheable::class)]
+    public function cacheMethod(JoinPoint $joinPoint): void
+    {
+        $cacheKey = $this->generateCacheKey($joinPoint);
+        
+        if ($this->cache->has($cacheKey)) {
+            $joinPoint->setReturnEarly(true);
+            $joinPoint->setReturnValue($this->cache->get($cacheKey));
+        }
+    }
+}
+```
+
+## Performance Monitoring
+
+Use the built-in Stopwatch attribute for performance monitoring:
 
 ```php
 use Tourze\Symfony\Aop\Attribute\Stopwatch;
@@ -116,32 +251,41 @@ class UserService
 
 ## Best Practices
 
-1. **Keep aspects focused**
-   - Each aspect should have a single responsibility
-   - Avoid heavy operations in advice methods
+### Keep Aspects Focused
+
+- Each aspect should have a single responsibility
+- Avoid heavy operations in advice methods
+- Use meaningful names for aspects and advice methods
+
+### Advice Execution Order
+
+- Before advice is executed in declaration order
+- After/AfterReturning/AfterThrowing advice is executed in reverse order
+- Consider the execution order when defining multiple aspects
+
+### Performance Considerations
 
-2. **Advice execution order**
-   - Before advice is executed in declaration order
-   - After/AfterReturning/AfterThrowing advice is executed in reverse order
+- Use AOP only when necessary
+- Consider the performance impact in production
+- Use Stopwatch to monitor method execution time
+- Avoid complex pointcut expressions in hot paths
 
-3. **Performance considerations**
-   - Use AOP only when necessary
-   - Consider the performance impact in production
-   - Use Stopwatch to monitor method execution time
+### Exception Handling
 
-4. **Exception handling**
-   - Be careful with exception handling in advice
-   - Consider using AfterThrowing for exception logging
-   - Use CatchException for controlled exception handling
+- Be careful with exception handling in advice
+- Consider using AfterThrowing for exception logging
+- Use CatchException for controlled exception handling
+- Test exception scenarios thoroughly
 
 ## Configuration
 
-No additional configuration is required. The bundle automatically detects services with the `#[Aspect]` attribute and applies advice to matching services.
+No additional configuration is required. The bundle automatically detects services with the 
+`#[Aspect]` attribute and applies advice to matching services.
 
 ## Contributing
 
 Contributions are welcome. Please feel free to submit a Pull Request.
 
 ## License
 
-This bundle is available under the MIT license. See the [LICENSE](LICENSE) file for more information.
+This bundle is available under the MIT license. See the [LICENSE](LICENSE) file for more information.