feat: implement advice params

qile222 · ximin.cxm · web-flow · commit 76ec8ad7b717 · 2023-06-20T10:37:09.000+08:00
---------

Co-authored-by: ximin.cxm &lt;ximin.cxm@antgroup.com&gt;
diff --git a/core/aop-decorator/index.ts b/core/aop-decorator/index.ts
@@ -1,6 +1,6 @@
 export * from './src/decorator/Advice';
 export * from './src/decorator/Pointcut';
-export * from './src/decorator/Cosscut';
+export * from './src/decorator/Crosscut';
 export * from './src/model/Aspect';
 export * from './src/model/PointcutInfo';
 export * from './src/util/AdviceInfoUtil';
diff --git a/core/aop-decorator/src/decorator/Advice.ts b/core/aop-decorator/src/decorator/Advice.ts
@@ -8,10 +8,11 @@ import {
 import { AdviceInfoUtil } from '../util/AdviceInfoUtil';
 import { StackUtil } from '@eggjs/tegg-common-util';
 
-export interface AdviceContext<T = object> {
+export interface AdviceContext<T = object, K = any> {
   that: T;
   method: PropertyKey;
   args: any[];
+  adviceParams?: K;
 }
 
 /**
@@ -21,33 +22,33 @@ export interface AdviceContext<T = object> {
  * 1. afterReturn/afterThrow
  * 1. afterFinally
  */
-export interface IAdvice<T = object> {
+export interface IAdvice<T = object, K = any> {
   /**
    * call before function
    * @param ctx
    */
-  beforeCall?(ctx: AdviceContext<T>): Promise<void>;
+  beforeCall?(ctx: AdviceContext<T, K>): Promise<void>;
 
   /**
    * call after function succeed
    */
-  afterReturn?(ctx: AdviceContext<T>, result: any): Promise<void>;
+  afterReturn?(ctx: AdviceContext<T, K>, result: any): Promise<void>;
 
   /**
    * call after function throw error
    */
-  afterThrow?(ctx: AdviceContext<T>, error: Error): Promise<void>;
+  afterThrow?(ctx: AdviceContext<T, K>, error: Error): Promise<void>;
 
   /**
    * always call after function done
    */
-  afterFinally?(ctx: AdviceContext<T>): Promise<void>;
+  afterFinally?(ctx: AdviceContext<T, K>): Promise<void>;
 
   /**
    * execute the function
    * the only one can modify the function return value
    */
-  around?(ctx: AdviceContext<T>, next: () => Promise<any>): Promise<any>;
+  around?(ctx: AdviceContext<T, K>, next: () => Promise<any>): Promise<any>;
 }
 
 const defaultAdviceParam = {
diff --git a/core/aop-decorator/src/decorator/Crosscut.ts b/core/aop-decorator/src/decorator/Crosscut.ts
@@ -12,6 +12,7 @@ import {
 export interface CrosscutOptions {
   // 默认值 100
   order?: number;
+  adviceParams?: any;
 }
 
 const defaultCrossOptions = {
@@ -48,6 +49,7 @@ export function Crosscut(param: CrosscutParam, options?: CrosscutOptions) {
         adviceInfo: {
           clazz: constructor,
           order: options?.order ?? defaultCrossOptions.order,
+          adviceParams: options?.adviceParams,
         },
       };
     } else if (param.type === PointcutType.NAME) {
@@ -56,6 +58,7 @@ export function Crosscut(param: CrosscutParam, options?: CrosscutOptions) {
         adviceInfo: {
           clazz: constructor,
           order: options?.order ?? defaultCrossOptions.order,
+          adviceParams: options?.adviceParams,
         },
       };
     } else {
@@ -64,6 +67,7 @@ export function Crosscut(param: CrosscutParam, options?: CrosscutOptions) {
         adviceInfo: {
           clazz: constructor,
           order: options?.order ?? defaultCrossOptions.order,
+          adviceParams: options?.adviceParams,
         },
       };
     }
diff --git a/core/aop-decorator/src/decorator/Pointcut.ts b/core/aop-decorator/src/decorator/Pointcut.ts
@@ -7,6 +7,7 @@ import { AdviceInfoUtil } from '../util/AdviceInfoUtil';
 export interface PointcutOptions {
   // default is 1000
   order?: number;
+  adviceParams?: any;
 }
 
 const defaultPointcutOptions = {
@@ -21,6 +22,7 @@ export function Pointcut(adviceClazz: EggProtoImplClass<IAdvice>, options?: Poin
     PointcutAdviceInfoUtil.addPointcutAdviceInfo({
       clazz: adviceClazz,
       order: options?.order ?? defaultPointcutOptions.order,
+      adviceParams: options?.adviceParams,
     }, targetClazz, methodName);
   };
 }
diff --git a/core/aop-decorator/src/model/Aspect.ts b/core/aop-decorator/src/model/Aspect.ts
@@ -4,11 +4,13 @@ import { IAdvice } from '../decorator/Advice';
 export interface AdviceInfo {
   clazz: EggProtoImplClass<IAdvice>;
   order: number;
+  adviceParams: any;
 }
 
 export interface AspectAdvice {
   name: string;
   clazz: EggProtoImplClass<IAdvice>;
+  adviceParams: any;
 }
 
 export class Aspect {
@@ -44,6 +46,7 @@ export class AspectBuilder {
       return {
         clazz: t.clazz,
         name: this.adviceName(t.clazz, i),
+        adviceParams: t.adviceParams,
       };
     });
     return new Aspect(this.clazz, this.method, aspectAdviceList);
diff --git a/core/aop-decorator/test/AspectMetaBuilder.test.ts b/core/aop-decorator/test/AspectMetaBuilder.test.ts
@@ -45,8 +45,8 @@ describe('test/AspectMetaBuild.test.ts', () => {
       const advices = aspect.adviceList;
 
       assert.deepStrictEqual(advices, [
-        { name: 'PointcutExample#hello#PointcutAdviceBeforeCallExample#0', clazz: PointcutAdviceBeforeCallExample },
-        { name: 'PointcutExample#hello#PointcutAdviceAfterReturnExample#1', clazz: PointcutAdviceAfterReturnExample },
+        { name: 'PointcutExample#hello#PointcutAdviceBeforeCallExample#0', clazz: PointcutAdviceBeforeCallExample, adviceParams: undefined },
+        { name: 'PointcutExample#hello#PointcutAdviceAfterReturnExample#1', clazz: PointcutAdviceAfterReturnExample, adviceParams: undefined },
       ]);
     });
   });
@@ -63,9 +63,9 @@ describe('test/AspectMetaBuild.test.ts', () => {
       assert(aspect.method === 'hello');
       const advices = aspect.adviceList;
       assert.deepStrictEqual(advices, [
-        { name: 'CrosscutExample#hello#CrosscutClassAdviceExample#0', clazz: CrosscutClassAdviceExample },
-        { name: 'CrosscutExample#hello#CrosscutNameAdviceExample#1', clazz: CrosscutNameAdviceExample },
-        { name: 'CrosscutExample#hello#CrosscutCustomAdviceExample#2', clazz: CrosscutCustomAdviceExample },
+        { name: 'CrosscutExample#hello#CrosscutClassAdviceExample#0', clazz: CrosscutClassAdviceExample, adviceParams: undefined },
+        { name: 'CrosscutExample#hello#CrosscutNameAdviceExample#1', clazz: CrosscutNameAdviceExample, adviceParams: undefined },
+        { name: 'CrosscutExample#hello#CrosscutCustomAdviceExample#2', clazz: CrosscutCustomAdviceExample, adviceParams: undefined },
       ]);
     });
   });
@@ -83,20 +83,20 @@ describe('test/AspectMetaBuild.test.ts', () => {
       const overwriteAdvices = overwriteAspect.adviceList;
 
       assert.deepStrictEqual(overwriteAdvices, [
-        { name: 'ChildExample#overwriteMethod#CrosscutOverwriteParentExample#0', clazz: CrosscutOverwriteParentExample },
-        { name: 'ChildExample#overwriteMethod#CrosscutOverwriteChildExample#1', clazz: CrosscutOverwriteChildExample },
+        { name: 'ChildExample#overwriteMethod#CrosscutOverwriteParentExample#0', clazz: CrosscutOverwriteParentExample, adviceParams: undefined },
+        { name: 'ChildExample#overwriteMethod#CrosscutOverwriteChildExample#1', clazz: CrosscutOverwriteChildExample, adviceParams: undefined },
         // FIXME: parent/child should has correct order
-        { name: 'ChildExample#overwriteMethod#PointcutAdviceOverwriteChildExample#2', clazz: PointcutAdviceOverwriteChildExample },
-        { name: 'ChildExample#overwriteMethod#PointcutAdviceOverwriteParentExample#3', clazz: PointcutAdviceOverwriteParentExample },
+        { name: 'ChildExample#overwriteMethod#PointcutAdviceOverwriteChildExample#2', clazz: PointcutAdviceOverwriteChildExample, adviceParams: undefined },
+        { name: 'ChildExample#overwriteMethod#PointcutAdviceOverwriteParentExample#3', clazz: PointcutAdviceOverwriteParentExample, adviceParams: undefined },
       ]);
 
       const noOverwriteAspect = aspects.find(t => t.method === 'noOverwriteMethod');
       assert(noOverwriteAspect);
       assert(noOverwriteAspect.clazz === ChildExample);
       const noOverwriteAdvices = noOverwriteAspect.adviceList;
       assert.deepStrictEqual(noOverwriteAdvices, [
-        { name: 'ChildExample#noOverwriteMethod#CrosscutNoOverwriteParentExample#0', clazz: CrosscutNoOverwriteParentExample },
-        { name: 'ChildExample#noOverwriteMethod#PointcutAdviceNoOverwriteParentExample#1', clazz: PointcutAdviceNoOverwriteParentExample },
+        { name: 'ChildExample#noOverwriteMethod#CrosscutNoOverwriteParentExample#0', clazz: CrosscutNoOverwriteParentExample, adviceParams: undefined },
+        { name: 'ChildExample#noOverwriteMethod#PointcutAdviceNoOverwriteParentExample#1', clazz: PointcutAdviceNoOverwriteParentExample, adviceParams: undefined },
       ]);
     });
 
@@ -112,17 +112,17 @@ describe('test/AspectMetaBuild.test.ts', () => {
       assert(overwriteAspect.clazz === ParentExample);
       const overwriteAdvices = overwriteAspect.adviceList;
       assert.deepStrictEqual(overwriteAdvices, [
-        { name: 'ParentExample#overwriteMethod#CrosscutOverwriteParentExample#0', clazz: CrosscutOverwriteParentExample },
-        { name: 'ParentExample#overwriteMethod#PointcutAdviceOverwriteParentExample#1', clazz: PointcutAdviceOverwriteParentExample },
+        { name: 'ParentExample#overwriteMethod#CrosscutOverwriteParentExample#0', clazz: CrosscutOverwriteParentExample, adviceParams: undefined },
+        { name: 'ParentExample#overwriteMethod#PointcutAdviceOverwriteParentExample#1', clazz: PointcutAdviceOverwriteParentExample, adviceParams: undefined },
       ]);
 
       const noOverwriteAspect = aspects.find(t => t.method === 'noOverwriteMethod');
       assert(noOverwriteAspect);
       assert(noOverwriteAspect.clazz === ParentExample);
       const noOverwriteAdvices = noOverwriteAspect.adviceList;
       assert.deepStrictEqual(noOverwriteAdvices, [
-        { name: 'ParentExample#noOverwriteMethod#CrosscutNoOverwriteParentExample#0', clazz: CrosscutNoOverwriteParentExample },
-        { name: 'ParentExample#noOverwriteMethod#PointcutAdviceNoOverwriteParentExample#1', clazz: PointcutAdviceNoOverwriteParentExample },
+        { name: 'ParentExample#noOverwriteMethod#CrosscutNoOverwriteParentExample#0', clazz: CrosscutNoOverwriteParentExample, adviceParams: undefined },
+        { name: 'ParentExample#noOverwriteMethod#PointcutAdviceNoOverwriteParentExample#1', clazz: PointcutAdviceNoOverwriteParentExample, adviceParams: undefined },
       ]);
     });
   });
diff --git a/core/aop-decorator/test/fixtures/InheritExample.ts b/core/aop-decorator/test/fixtures/InheritExample.ts
@@ -1,7 +1,7 @@
 import { ContextProto } from '@eggjs/core-decorator';
 import { Advice, AdviceContext, IAdvice } from '../../src/decorator/Advice';
 import { Pointcut } from '../../src/decorator/Pointcut';
-import { Crosscut } from '../../src/decorator/Cosscut';
+import { Crosscut } from '../../src/decorator/Crosscut';
 import { PointcutType } from '../../src/model/PointcutInfo';
 
 @Advice()
diff --git a/core/aop-runtime/src/AspectExecutor.ts b/core/aop-runtime/src/AspectExecutor.ts
@@ -2,6 +2,12 @@ import { AdviceContext, AspectAdvice, IAdvice } from '@eggjs/aop-decorator';
 import compose from 'koa-compose';
 import type { Middleware } from 'koa-compose';
 
+interface InternalAdviceContext<T = object> {
+  that: T;
+  method: PropertyKey;
+  args: any[];
+}
+
 export class AspectExecutor {
   obj: Object;
   method: PropertyKey;
@@ -14,7 +20,7 @@ export class AspectExecutor {
   }
 
   async execute(...args: any[]) {
-    const ctx: AdviceContext = {
+    const ctx: InternalAdviceContext = {
       that: this.obj,
       method: this.method,
       args,
@@ -32,53 +38,59 @@ export class AspectExecutor {
     }
   }
 
-  async beforeCall(ctx: AdviceContext) {
+  async beforeCall(ctx: InternalAdviceContext) {
     for (const aspectAdvice of this.aspectAdviceList) {
       const advice: IAdvice = ctx.that[aspectAdvice.name];
       if (advice.beforeCall) {
-        await advice.beforeCall(ctx);
+        await advice.beforeCall({ ...ctx, adviceParams: aspectAdvice.adviceParams });
       }
     }
   }
 
-  async afterReturn(ctx: AdviceContext, result: any) {
+  async afterReturn(ctx: InternalAdviceContext, result: any) {
     for (const aspectAdvice of this.aspectAdviceList) {
       const advice: IAdvice = ctx.that[aspectAdvice.name];
       if (advice.afterReturn) {
-        await advice.afterReturn(ctx, result);
+        await advice.afterReturn({ ...ctx, adviceParams: aspectAdvice.adviceParams }, result);
       }
     }
   }
 
-  async afterThrow(ctx: AdviceContext, error: Error) {
+  async afterThrow(ctx: InternalAdviceContext, error: Error) {
     for (const aspectAdvice of this.aspectAdviceList) {
       const advice: IAdvice = ctx.that[aspectAdvice.name];
       if (advice.afterThrow) {
-        await advice.afterThrow(ctx, error);
+        await advice.afterThrow({ ...ctx, adviceParams: aspectAdvice.adviceParams }, error);
       }
     }
   }
 
-  async afterFinally(ctx: AdviceContext) {
+  async afterFinally(ctx: InternalAdviceContext) {
     for (const aspectAdvice of this.aspectAdviceList) {
       const advice: IAdvice = ctx.that[aspectAdvice.name];
       if (advice.afterFinally) {
-        await advice.afterFinally(ctx);
+        await advice.afterFinally({ ...ctx, adviceParams: aspectAdvice.adviceParams });
       }
     }
   }
 
-  async doExecute(ctx: AdviceContext) {
+  async doExecute(ctx: InternalAdviceContext) {
     const lastCall = () => {
       const originMethod = Object.getPrototypeOf(this.obj)[this.method];
       return Reflect.apply(originMethod, ctx.that, ctx.args);
     };
-    const functions: Array<Middleware<AdviceContext>> = [];
+    const functions: Array<Middleware<InternalAdviceContext>> = [];
     for (const aspectAdvice of this.aspectAdviceList) {
       const advice: IAdvice = ctx.that[aspectAdvice.name];
       const fn = advice.around;
       if (fn) {
-        functions.push(fn.bind(advice));
+        functions.push(async (ctx: InternalAdviceContext<object>, next: () => Promise<any>) => {
+          const fnCtx: AdviceContext = {
+            ...ctx,
+            adviceParams: aspectAdvice.adviceParams,
+          };
+          return await fn.call(advice, fnCtx, next);
+        });
       }
     }
     functions.push(lastCall);
diff --git a/core/aop-runtime/test/aop-runtime.test.ts b/core/aop-runtime/test/aop-runtime.test.ts
@@ -5,7 +5,7 @@ import { EggObjectLifecycleUtil, LoadUnitInstance, LoadUnitInstanceFactory } fro
 import { EggPrototypeLifecycleUtil, LoadUnitFactory, LoadUnitLifecycleUtil } from '@eggjs/tegg-metadata';
 import { CrosscutAdviceFactory } from '@eggjs/aop-decorator';
 import { EggTestContext } from '../../test-util';
-import { CallTrace, Hello } from './fixtures/modules/hello_succeed/Hello';
+import { CallTrace, Hello, crosscutAdviceParams, pointcutAdviceParams } from './fixtures/modules/hello_succeed/Hello';
 import { CoreTestHelper } from '../../test-util/CoreTestHelper';
 import { EggObjectAopHook } from '../src/EggObjectAopHook';
 import { LoadUnitAopHook } from '../src/LoadUnitAopHook';
@@ -50,47 +50,65 @@ describe('test/aop-runtime.test.ts', () => {
         const callTrace = await CoreTestHelper.getObject(CallTrace);
         const msg = await hello.hello('aop');
         const traceMsg = callTrace.msgs;
-        assert(msg === 'withCrossAroundResult(withPointAroundResult(hello withPointAroundParam(withCrosscutAroundParam(aop))))');
+        assert.deepStrictEqual(msg, `withCrossAroundResult(withPointAroundResult(hello withPointAroundParam(withCrosscutAroundParam(aop))${JSON.stringify(pointcutAdviceParams)})${JSON.stringify(crosscutAdviceParams)})`);
         assert.deepStrictEqual(traceMsg, [
           {
             className: 'CrosscutAdvice',
             methodName: 'beforeCall',
             id: 233,
             name: 'aop',
+            adviceParams: crosscutAdviceParams,
           },
           {
             className: 'PointcutAdvice',
             methodName: 'beforeCall',
             id: 233,
             name: 'aop',
+            adviceParams: pointcutAdviceParams,
           },
           {
             className: 'CrosscutAdvice',
             methodName: 'afterReturn',
             id: 233,
             name: 'withPointAroundParam(withCrosscutAroundParam(aop))',
-            result: 'withCrossAroundResult(withPointAroundResult(hello withPointAroundParam(withCrosscutAroundParam(aop))))',
+            result: `withCrossAroundResult(withPointAroundResult(hello withPointAroundParam(withCrosscutAroundParam(aop))${JSON.stringify(pointcutAdviceParams)})${JSON.stringify(crosscutAdviceParams)})`,
+            adviceParams: crosscutAdviceParams,
           },
           {
             className: 'PointcutAdvice',
             methodName: 'afterReturn',
             id: 233,
             name: 'withPointAroundParam(withCrosscutAroundParam(aop))',
-            result: 'withCrossAroundResult(withPointAroundResult(hello withPointAroundParam(withCrosscutAroundParam(aop))))',
+            result: `withCrossAroundResult(withPointAroundResult(hello withPointAroundParam(withCrosscutAroundParam(aop))${JSON.stringify(pointcutAdviceParams)})${JSON.stringify(crosscutAdviceParams)})`,
+            adviceParams: pointcutAdviceParams,
           },
           {
             className: 'CrosscutAdvice',
             methodName: 'afterFinally',
             id: 233,
             name: 'withPointAroundParam(withCrosscutAroundParam(aop))',
+            adviceParams: crosscutAdviceParams,
           },
           {
             className: 'PointcutAdvice',
             methodName: 'afterFinally',
             id: 233,
             name: 'withPointAroundParam(withCrosscutAroundParam(aop))',
+            adviceParams: pointcutAdviceParams,
           },
         ]);
+
+        await assert.rejects(async () => {
+          await hello.helloWithException('foo');
+        }, new Error('ops, exception for withPointAroundParam(foo)'));
+        assert.deepStrictEqual(callTrace.msgs[callTrace.msgs.length - 2], {
+          className: 'PointcutAdvice',
+          methodName: 'afterThrow',
+          id: 233,
+          name: 'withPointAroundParam(foo)',
+          result: 'ops, exception for withPointAroundParam(foo)',
+          adviceParams: pointcutAdviceParams,
+        });
       });
     });
 
diff --git a/core/aop-runtime/test/fixtures/modules/hello_succeed/Hello.ts b/core/aop-runtime/test/fixtures/modules/hello_succeed/Hello.ts
diff --git a/plugin/aop/README.md b/plugin/aop/README.md

Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,7 @@ import { AdviceInfoUtil } from '../util/AdviceInfoUtil';`
`7`	`7`	`export interface PointcutOptions {`
`8`	`8`	`// default is 1000`
`9`	`9`	`order?: number;`
	`10`	`+ adviceParams?: any;`
`10`	`11`	`}`
`11`	`12`
`12`	`13`	`const defaultPointcutOptions = {`
`@@ -21,6 +22,7 @@ export function Pointcut(adviceClazz: EggProtoImplClass<IAdvice>, options?: Poin`
`21`	`22`	`PointcutAdviceInfoUtil.addPointcutAdviceInfo({`
`22`	`23`	`clazz: adviceClazz,`
`23`	`24`	`order: options?.order ?? defaultPointcutOptions.order,`
	`25`	`+ adviceParams: options?.adviceParams,`
`24`	`26`	`}, targetClazz, methodName);`
`25`	`27`	`};`
`26`	`28`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,12 @@ import { AdviceContext, AspectAdvice, IAdvice } from '@eggjs/aop-decorator';`
`2`	`2`	`import compose from 'koa-compose';`
`3`	`3`	`import type { Middleware } from 'koa-compose';`
`4`	`4`
	`5`	`+interface InternalAdviceContext<T = object> {`
	`6`	`+ that: T;`
	`7`	`+ method: PropertyKey;`
	`8`	`+ args: any[];`
	`9`	`+}`
	`10`	`+`
`5`	`11`	`export class AspectExecutor {`
`6`	`12`	`obj: Object;`
`7`	`13`	`method: PropertyKey;`
`@@ -14,7 +20,7 @@ export class AspectExecutor {`
`14`	`20`	`}`
`15`	`21`
`16`	`22`	`async execute(...args: any[]) {`
`17`		`- const ctx: AdviceContext = {`
	`23`	`+ const ctx: InternalAdviceContext = {`
`18`	`24`	`that: this.obj,`
`19`	`25`	`method: this.method,`
`20`	`26`	`args,`
`@@ -32,53 +38,59 @@ export class AspectExecutor {`
`32`	`38`	`}`
`33`	`39`	`}`
`34`	`40`
`35`		`- async beforeCall(ctx: AdviceContext) {`
	`41`	`+ async beforeCall(ctx: InternalAdviceContext) {`
`36`	`42`	`for (const aspectAdvice of this.aspectAdviceList) {`
`37`	`43`	`const advice: IAdvice = ctx.that[aspectAdvice.name];`
`38`	`44`	`if (advice.beforeCall) {`
`39`		`- await advice.beforeCall(ctx);`
	`45`	`+ await advice.beforeCall({ ...ctx, adviceParams: aspectAdvice.adviceParams });`
`40`	`46`	`}`
`41`	`47`	`}`
`42`	`48`	`}`
`43`	`49`
`44`		`- async afterReturn(ctx: AdviceContext, result: any) {`
	`50`	`+ async afterReturn(ctx: InternalAdviceContext, result: any) {`
`45`	`51`	`for (const aspectAdvice of this.aspectAdviceList) {`
`46`	`52`	`const advice: IAdvice = ctx.that[aspectAdvice.name];`
`47`	`53`	`if (advice.afterReturn) {`
`48`		`- await advice.afterReturn(ctx, result);`
	`54`	`+ await advice.afterReturn({ ...ctx, adviceParams: aspectAdvice.adviceParams }, result);`
`49`	`55`	`}`
`50`	`56`	`}`
`51`	`57`	`}`
`52`	`58`
`53`		`- async afterThrow(ctx: AdviceContext, error: Error) {`
	`59`	`+ async afterThrow(ctx: InternalAdviceContext, error: Error) {`
`54`	`60`	`for (const aspectAdvice of this.aspectAdviceList) {`
`55`	`61`	`const advice: IAdvice = ctx.that[aspectAdvice.name];`
`56`	`62`	`if (advice.afterThrow) {`
`57`		`- await advice.afterThrow(ctx, error);`
	`63`	`+ await advice.afterThrow({ ...ctx, adviceParams: aspectAdvice.adviceParams }, error);`
`58`	`64`	`}`
`59`	`65`	`}`
`60`	`66`	`}`
`61`	`67`
`62`		`- async afterFinally(ctx: AdviceContext) {`
	`68`	`+ async afterFinally(ctx: InternalAdviceContext) {`
`63`	`69`	`for (const aspectAdvice of this.aspectAdviceList) {`
`64`	`70`	`const advice: IAdvice = ctx.that[aspectAdvice.name];`
`65`	`71`	`if (advice.afterFinally) {`
`66`		`- await advice.afterFinally(ctx);`
	`72`	`+ await advice.afterFinally({ ...ctx, adviceParams: aspectAdvice.adviceParams });`
`67`	`73`	`}`
`68`	`74`	`}`
`69`	`75`	`}`
`70`	`76`
`71`		`- async doExecute(ctx: AdviceContext) {`
	`77`	`+ async doExecute(ctx: InternalAdviceContext) {`
`72`	`78`	`const lastCall = () => {`
`73`	`79`	`const originMethod = Object.getPrototypeOf(this.obj)[this.method];`
`74`	`80`	`return Reflect.apply(originMethod, ctx.that, ctx.args);`
`75`	`81`	`};`
`76`		`- const functions: Array<Middleware<AdviceContext>> = [];`
	`82`	`+ const functions: Array<Middleware<InternalAdviceContext>> = [];`
`77`	`83`	`for (const aspectAdvice of this.aspectAdviceList) {`
`78`	`84`	`const advice: IAdvice = ctx.that[aspectAdvice.name];`
`79`	`85`	`const fn = advice.around;`
`80`	`86`	`if (fn) {`
`81`		`- functions.push(fn.bind(advice));`
	`87`	`+ functions.push(async (ctx: InternalAdviceContext<object>, next: () => Promise<any>) => {`
	`88`	`+ const fnCtx: AdviceContext = {`
	`89`	`+ ...ctx,`
	`90`	`+ adviceParams: aspectAdvice.adviceParams,`
	`91`	`+ };`
	`92`	`+ return await fn.call(advice, fnCtx, next);`
	`93`	`+ });`
`82`	`94`	`}`
`83`	`95`	`}`
`84`	`96`	`functions.push(lastCall);`