【鸿蒙实战开发】AOP面向切面编程实战

最新推荐文章于 2024-08-08 18:21:15 发布

鸿蒙初辟梦创道远

最新推荐文章于 2024-08-08 18:21:15 发布

阅读量652

点赞数 8

分类专栏：鸿蒙安卓前端文章标签： harmonyos 华为鸿蒙前端安卓

本文链接：https://blog.csdn.net/HarmonyOS_666/article/details/140334009

版权

鸿蒙同时被 3 个专栏收录

202 篇文章 1 订阅

订阅专栏

前端

202 篇文章 0 订阅

订阅专栏

安卓

201 篇文章 0 订阅

订阅专栏

前言

●AOP 简介
●ArkTs AOP 实现原理

○JS 原型链
○AOP实现原理

●AOP的应用场景

○统计类：方法调用次数统计、方法时长统计
○防御式编程：参数校验
○代理模式实现

●AOP的注意事项

一、AOP简介

对于Android、Java Web 开发者来说， AOP编程思想并不陌生。 AOP的使用核心在于要找到 Aspect（切面），然后再根据自己的需要，对某个“业务操作进”行前置或者后置的处理，甚至可以替换“该业务操作”。 AOP的操作粒度就是方法级别，一个方法包括接收数据、处理数据和返回数据这么三个部分：

AOP 在这三个阶段都可以添加自己的逻辑处理。 Java中常见的AOP框架有很多：AspectJ、SpringAOP、Javassist、Guice、Byte Buddy等。ArkTs在4.0版本中也支持了AOP，那么ArkTs是如何实现AOP的呢？

二、ArkTs AOP 实现原理

接下来，我们首先要了解一下JS对象的在继承体系中的引用关系，这样才能够精准的选择合适的方法来进行切面编程。然后我们在了解一下AOP是如何实现的。

2.1 JS 原型链

在这里插入图片描述

如上图所示：
水平维度：类通过prototype 引用着其原型对象，通过constructor引种着其构造函数；该类的构造函数中，关联着该类的静态方法；
竖直维度：类的原型对象通过__proto__指向父类原型对象；类的构造函数通过__proto__指向父类的构造函数；类的实例对象通过__proto__指向该类的原型对象；

那么对于实例对象a和对象b来说，其实例方法的定位如下图红色路径所示；对于类A和类B类说，其静态方法的的定位流程如下图蓝色路径所示:
在这里插入图片描述

通过上图，我们可以得出如下结论：
类的原型对象承载着该类对象的实例实例方法(非静态方法)，并且通过__proto__ 指向父类的原型对象，通过constructor指向类(也就是类的构造函数，需要额外指出的是类的静态方法存储在构造函数中)。类（类的构造函数）通过__proto__指向父类(父类的构造构造函数)。

2.2 AOP实现原理

AOP的实现依赖于插桩和替换来实现的，其本质上将回调参数和原方法组合成一个新的函数，再用新的函数替换原方法，具体如下图所示：

“计算机科学中的所有问题都可以通过增加一个额外的间接层来解决‘’

2.2.1 AddBefore 原理的伪代码

// addBefore 的伪代码实现
static addBefore(targetClass, methodName , isStatic , before:Function) : void {
    // 根据是否静态方法，获取要插装的对象（是“类” ，还是“类的原型对象”）
    let target = isStatic ? targetClass : targetClass.prototype;
    // 根据方法名，获取原有的方法
    let origin = target[methodName];
    /**
    * 定义新的方法（包装一层），实现优先执行before的逻辑，然后执行原有方法origin，
    * 最后将返回结果给 外层调用者。
    */
    let newFuncs = function(...args) {
        // 先执行before方法，再执行当前方法
        before(this,...args);
        return origin.bind(this)(...args);    
    }
    // 使用新函数生效
    target[methodName] = newFuncs；
}

2.2.2 AddAfter 原理的伪代码

// addAfter 的伪代码实现
static addAfter(targetClass, methodName , isStatic , after:Function) :void {
    let target = isStatic ? targetClass : target.protoType;
    let original = target[methodName];
    let newFuncs = function(...args) {
        let ret = origin.bind(this)(...args);
        return after(this,r,...args); 
    }
}

2.2.3 Repalce 原理的伪代码

static replace(targetClass, methodName , isStatic , instead) :void {
    let target = isStatic ? targetClass : target.protoType;
    let newFuncs = function(...args) {
        return instead(this,...args); 
    }
    target[methodName] = newFuncs;
}

三、AOP的应用场景

●统计类：方法调用次数统计、方法时长统计
●防御式编程：参数校验、返回值校验
●继承体系中的精确Hook
●代理模式和IOC

3.1 统计类

3.1.1 方法调用次数统计

export class Test {
    hello () {
        console.log('hello world')    
    }
}

我们通过Aspect.addBefore实现对Test类 hello方法调用次数的统计。

function main() {
    let countHello = 0;
    util.Aspect.addBefore(Test,'hello',false , ()=> {
        countHello++;
    });
    let h = new Test();
    console.log(`countHello : ${countHello}`)
    h.hello();
    console.log(`countHello : ${countHello}`)
}

3.1.2 方法时长统计

function addTimePrinter(target:Object, methodName:string, isStatic:boolean) {
    let t1 = 0;
    let t2 = 0;
    util.Aspect.addBefore(targetClass, methodName, isStatic, () => {
        t1 = new Date().getTime();
    });
    util.Aspect.addAfter(targetClass, methodName, isStatic, () => {
        t2 = new Date().getTime();
        console.log("t2---t1 = " + (t2 - t1).toString());
    });
}

测试addTimePrinter的功能：

export class View {
    onDraw() {
        // ...             
    }
    
    static cinit() {
        // ... 
    }
}


function main() {
    // 测试静态方法的时长统计
    addTimePrinter(Test,'cinit',true);
    View.cinit();
    // 测试实例方法的时长统计
    addTimePrinter(Test,'onDraw',true);
    new View().cinit();
}

3.2 防御式编程

●校验参数
●纠正返回值

3.2.1 校验参数

export class P004_View {
  children:P004_View[];

  constructor(children:Array<P004_View>) {
    this.children = children
  }

  getViewByIndex(index:number):P004_View {
    return this.children[index];
  }
}

上述View类的实例方法 getViewByIndex 的入参是一个index, 为了避免索引越界情况，我们可以通过Aspect类addBefore，增加一层”参数校验“的逻辑。

util.Aspect.addBefore(P004_View,"getViewByIndex",false, (view:P004_View, index:number)=> {
  if(view.children) {
    throw Error('view.children is undefined !')
  }

  if(index <= 0) {
    throw Error('index can not be negative !')
  }

  if((view.children as P004_View[]).length <= index) {
    throw Error('index is too big !')
  }
})

3.2.2 纠正返回值

export class P004_Random {        
    static randomSmallerThan50():number {
        return Math.floor(Math.random() * 52);
    }
}

randomSmallerThan50 方法的返回值期望是[0,50], 但是目前返回之返回是[0,51] , 我们可以使用Aspect类的addAfter方法，对返回值进行修正

export function testRandom() {
  util.Aspect.addAfter(P004_Random,'randomSmallerThan50',true,(target:P004_Random,ret:number)=> {
    if(ret > 50) {
      return P004_Random.randomSmallerThan50()
    } else {
      console.log(`P004_Random_randomSmallerThan50_addAfter ${ret}`)
      return ret;
    }
  })
  P004_Random.randomSmallerThan50()
}

3.3 子类实例方法替换

export class AirCraft {
  fly() {
    console.log('fight....')
  }
}

export class USA_AirCraft extends AirCraft{}

export class CN_AirCraft extends AirCraft{}

我们也可以通过Aspect类实现对子类的某个方法的插桩或者替换。下面是替换USA_AirCraft类的fly方法的代码：

export function testAirCraft() {
  let cn = new CN_AirCraft()
  let usa = new USA_AirCraft();

  cn.fly()
  usa.fly()

  util.Aspect.replace(USA_AirCraft,"fly",false,()=> {
    console.log('runaway....')
  })

  cn.fly()
  usa.fly();
}

3.4 控制反转（IOC）

AOP 也可以实现控制反转。如下图所示， PlayerManager 封装了播放器IPlayer接口，IPlayer 有ijkPlayer和mediaPlayer两个子类。我们可以通过AOP 替换PlayerManager中的init() start() 等方法，来实现两种Player对象的切换。
在这里插入图片描述

上图中UML中的类，对应代码如下：

interface IPlayer {

  init(): void

  start(): void

  stop(): void

  release(): void
}

export class PlayManager {
  player?: IPlayer

  init(): void {
  }

  start(): void {
  }

  stop(): void {
  }

  release(): void {
  }
}

export class IjkPlayer implements IPlayer {
  init(): void {
    console.log('IjkPlayer init ...')
  }

  start(): void {
    console.log('IjkPlayer start ...')
  }

  stop(): void {
    console.log('IjkPlayer stop ...')
  }


  release(): void {
    console.log('IjkPlayer release ...')
  }
}


export class MediaPlayer implements IPlayer {
  init(): void {
    console.log('MediaPlayer init ...')
  }

  start(): void {
    console.log('MediaPlayer start ...')
  }

  stop(): void {
    console.log('MediaPlayer stop ...')
  }


  release(): void {
    console.log('MediaPlayer release ...')
  }
}

接下来，我们通过Aspect的replace方法来实现 player对象的替换：

/*
* 该方法 根据methodName，返回一个函数。该函数中会 当前player的对应的方法，并返回。 
*/
export function providePlayer(methodName: string, playerFetcher: ()=>IPlayer) {
  return (manager: PlayManager) => {
    if (methodName === 'init') {
      return playerFetcher().start()
    } else if (methodName === 'init') {
      return playerFetcher().start()
    } else if (methodName === 'start') {
      return playerFetcher().start()
    } else if (methodName === 'stop') {
      return playerFetcher().start()
    } else if (methodName === 'release') {
      return playerFetcher().release()
    }
  }
}


export function testPlayer() {
  let player:IPlayer = new IjkPlayer()
  // 通过replace， 替换对应的方法。
  util.Aspect.replace(PlayManager, "init", false, providePlayer("init",()=> player))
  util.Aspect.replace(PlayManager, "start", false, providePlayer("start",()=> player))
  util.Aspect.replace(PlayManager, "stop", false, providePlayer("stop",() => player))
  util.Aspect.replace(PlayManager, "release", false, providePlayer("release",()=> player))

  let playManager = new PlayManager()
  playManager.init()
  // 替换成MediaPlayer
  player = new MediaPlayer()
  playManager.start()
}

四、AOP注意事项

1.插桩的目标类通常需要导入进来，对于没有导出的场景，如果有实例，可以通过实例的constructor属性获取目标类。（这里告诉我们导入的类是一个类对象）

 // 类实例对象的constructor ，指向类对象。 
 util.Aspect.addBefore(this.context.constructor, 'startAbility', false,
      (instance: Object, wantParam: Want) => {
        console.info('UIAbilityContext startAbility: want.bundleName is ' + wantParam.bundleName);
      });

2.需要明确插桩的影响范围（可以根据JS原型链去理解）。
3. addBefore 注意事项：

util.Aspect.addBefore(Test, 'foo', false, (instance: Test) => { // 该函数的参数 第一个是一个对象，后续参数 则需要参考 源于函数声明
  ....
});
// 如果想要调用原有的函数，可以使用一个变量进行传递：
let oringalFoo = new Test().foo;
util.Aspect.addBefore(Test, 'foo', false, (instance: Test) => { // 该函数的参数 第一个是一个对象，后续参数 则需要参考 原函数声明
  // 方式一：如果原方法没有使用this，则可以直接调用原方法
  oringalFoo();
  // 方式二：如果原方法中使用了this，应该使用bind绑定instance，但是会有编译warning
  oringalFoo.bind(instance);
});

4.addAfter 注意事项：

util.Aspect.addAfter(Test, 'foo', false, (instance: Test, ret: string) => { // 该函数的参数 第一个是一个对象，第二个参数是 原函数的返回值
  console.log('execute foo');
  return ret;  // 一定要将原方法的返回值 传递出去
});

5.struct 不能插桩和替换；方法的属性为只读时，不可以插桩和替换; 构造函数也不能被插桩和替换

写在最后

有很多小伙伴不知道学习哪些鸿蒙开发技术？不知道需要重点掌握哪些鸿蒙应用开发知识点？而且学习时频繁踩坑，最终浪费大量时间。所以有一份实用的鸿蒙（HarmonyOS NEXT）资料用来跟着学习是非常有必要的。

这份鸿蒙（HarmonyOS NEXT）资料包含了鸿蒙开发必掌握的核心知识要点，内容包含了（ArkTS、ArkUI开发组件、Stage模型、多端部署、分布式应用开发、音频、视频、WebGL、OpenHarmony多媒体技术、Napi组件、OpenHarmony内核、Harmony南向开发、鸿蒙项目实战等等）鸿蒙（HarmonyOS NEXT）技术知识点。

希望这一份鸿蒙学习资料能够给大家带来帮助，有需要的小伙伴自行领取，限时开源，先到先得~无套路领取！！

获取这份完整版高清学习路线，请点击→纯血版全套鸿蒙HarmonyOS学习资料

鸿蒙（HarmonyOS NEXT）最新学习路线

在这里插入图片描述

有了路线图，怎么能没有学习资料呢，小编也准备了一份联合鸿蒙官方发布笔记整理收纳的一套系统性的鸿蒙（OpenHarmony ）学习手册（共计1236页）与鸿蒙（OpenHarmony ）开发入门教学视频，内容包含：ArkTS、ArkUI、Web开发、应用模型、资源分类…等知识点。

获取以上完整版高清学习路线，请点击→纯血版全套鸿蒙HarmonyOS学习资料

《鸿蒙 (OpenHarmony)开发入门教学视频》

在这里插入图片描述

《鸿蒙生态应用开发V3.0白皮书》

在这里插入图片描述

《鸿蒙 (OpenHarmony)开发基础到实战手册》

OpenHarmony北向、南向开发环境搭建

在这里插入图片描述

《鸿蒙开发基础》

●ArkTS语言
●安装DevEco Studio
●运用你的第一个ArkTS应用
●ArkUI声明式UI开发
.……
在这里插入图片描述

《鸿蒙开发进阶》

●Stage模型入门
●网络管理
●数据管理
●电话服务
●分布式应用开发
●通知与窗口管理
●多媒体技术
●安全技能
●任务管理
●WebGL
●国际化开发
●应用测试
●DFX面向未来设计
●鸿蒙系统移植和裁剪定制
……
在这里插入图片描述

《鸿蒙进阶实战》

●ArkTS实践
●UIAbility应用
●网络案例
……
在这里插入图片描述

获取以上完整鸿蒙HarmonyOS学习资料，请点击→纯血版全套鸿蒙HarmonyOS学习资料

鸿蒙初辟梦创道远

关注

8
点赞
踩
27

收藏

觉得还不错? 一键收藏
0
评论
【鸿蒙实战开发】AOP面向切面编程实战

对于Android、Java Web 开发者来说， AOP编程思想并不陌生。AOP的使用核心在于要找到 Aspect（切面），然后再根据自己的需要，对某个“业务操作进”行前置或者后置的处理，甚至可以替换“该业务操作”。AOP的操作粒度就是方法级别，一个方法包括接收数据、处理数据和返回数据这么三个部分：AOP 在这三个阶段都可以添加自己的逻辑处理。Java中常见的AOP框架有很多：AspectJ、SpringAOP、Javassist、Guice、Byte Buddy等。
复制链接

扫一扫

专栏目录