HarmonyOS 鸿蒙Next中MSI大型项目里需要在调用时操作大量类的实例化

HarmonyOS 鸿蒙Next中MSI大型项目里需要在调用时操作大量类的实例化 APP里有不同的容器，不同的容器都需要引入MSI，那为了不让不同容器内相关的功能互相串，就需要确保我们功能的载体class不能是相同的单实例。那现在的问题是，如果在写class的位置导出实例，那就是单实例；如果想在注册APIClass的时候实例化，现在鸿蒙不支持。

// A.ets
export class ClassA {
    onRegister() {
        // ClassA 的注册逻辑
    }
}

// B.ets
export class ClassB {
    onRegister() {
        // ClassB 的注册逻辑
    }
}

// C.ets
export class ClassC {
    onRegister() {
        // ClassC 的注册逻辑
    }
}

// Index.ets
const List = [ClassA, ClassB, ClassC];

// msi.ets
class MSI {
    map = new Map();

    constructor() {
        this.init();
    }

    init() {
        List.map(ClassItem => {
            // 此处我们需要 new 才能保证容器 A 和 B 调到的实例不是同一个
            const instance = new ClassItem();
            instance.onRegister();
            this.map.set(ClassItem.name, instance);
        });
    }
}

// 容器A
const containerA = new MSI();

// 容器B
const containerB = new MSI();

更多关于HarmonyOS 鸿蒙Next中MSI大型项目里需要在调用时操作大量类的实例化的实战教程也可以访问 https://www.itying.com/category-93-b0.html

sinazl 1楼

请参见如下demo代码：

A. ets

export class ClassA {
    testvalue: number = 1;
    constructor() {}
    onRegister() {
        this.testvalue = 2;
    }
    setValue(value: number) {
        this.testvalue = value;
    }
    getValue(): number {
        return this.testvalue;
    }
}
export default new ClassA();

B. ets:

export class ClassB {
    testvalue: number = 1;
    constructor() {}
    onRegister() {}

    setValue(value: number) {
        this.testvalue = value;
    }
    getValue(): number {
        return this.testvalue;
    }
}
export default new ClassB();

C. ets:

export class ClassC {
    testvalue: number = 1;
    constructor() {}
    onRegister() {}

    setValue(value: number) {
        this.testvalue = value;
    }
    getValue(): number {
        return this.testvalue;
    }
}
export default new ClassC();

D. ets:

export class ClassD {
    testvalue: number = 1;
    constructor() {}
    onRegister() {
        this.testvalue = 2;
    }
    setValue(value: number) {
        this.testvalue = value;
    }
    getValue(): number {
        return this.testvalue;
    }
}

export class ClassDD {
    testvalue: number = 1;
    constructor() {}
    onRegister() {
        this.testvalue = 2;
    }
    setValue(value: number) {
        this.testvalue = value;
    }
    getValue(): number {
        return this.testvalue;
    }
}

msi. ets:

import List from '@ohos.util.List';
import ClassA from './A';
import ClassB from './B';
import ClassC from './C';
import { ClassD, ClassDD } from './D';

export class MSI11 {
    List = [ClassA, ClassB, ClassC];
    d: ClassD = new ClassD();
    arr: ClassD[] = [];
    arr2 = [new ClassD(), new ClassDD()];
    constructor() {}

    init(flag: number) {
        this.List.map(ClassItem => {
            // 此处我们需要new才能保证容器A和B调到的实例不是同一个
            ClassItem.onRegister();
            if (flag == 1) {
                ClassItem.setValue(10);
                this.d.setValue(10);
            } else {
                ClassItem.setValue(20);
                this.d.setValue(20);
            }
        })
        if (flag == 1) {
            let testd: ClassD = new ClassD();
            testd.setValue(30);
            this.arr.push(testd);
            this.arr2[0].setValue(50);
            this.arr2[1].setValue(60);
        } else {
            let teste: ClassD = new ClassD();
            teste.setValue(40);
            this.arr.push(teste);
            this.arr2[0].setValue(70);
            this.arr2[1].setValue(80);
        }
        this.List.push(this.d);
        this.arr.push(this.d);
    }
    getvalue(): number {
        return this.arr[0].getValue();
    }
    getvalue2(): number {
        return this.arr[1].getValue();
    }
    getvalue3(): number {
        return this.arr2[0].getValue();
    }
    getvalue4(): number {
        return this.arr2[1].getValue();
    }
}

export class MSI22 { constructor() {} }

Index. ets:

import ClassA from './A';
import ClassB from './B';
import ClassC from './C';
import { MSI11 } from './msi';

const List = [ClassA, ClassB, ClassC];

// 容器A
ClassA.onRegister();
ClassB.onRegister();

let a = new MSI11();
let b = new MSI11();
a.init(1);
b.init(2);

@Entry
@Component
struct Index {
    @State message: string = 'Hello World';
    @State message2: string = 'Hello World2'
    @State message3: string = 'Hello World3';
    @State message4: string = 'Hello World4';
    @State message5: string = 'Hello World5';
    @State message6: string = 'Hello World6';

    build() {
        Row () {
            Column () {
                Text(this.message)
                    .fontSize(50)
                    .fontWeight(FontWeight.Bold)
                    .onClick(() => {
                        this.message = a.getvalue().toString()
                    });
                Text(this.message2)
                    .fontSize(50)
                    .fontWeight(FontWeight.Bold)
                    .onClick(() => {
                        this.message2 = b.getvalue().toString()
                    });
                Text(this.message3)
                    .fontSize(50)
                    .fontWeight(FontWeight.Bold)
                    .onClick(() => {
                        this.message3 = b.getvalue2().toString()
                    });
                Text(this.message4)
                    .fontSize(50)
                    .fontWeight(FontWeight.Bold)
                    .onClick(() => {
                        this.message4 = b.getvalue2().toString()
                    });
                Text(this.message5)
                    .fontSize(50)
                    .fontWeight(FontWeight.Bold)
                    .onClick(() => {
                        this.message5 = b.getvalue3().toString()
                    });
                Text(this.message6)
                    .fontSize(50)
                    .fontWeight(FontWeight.Bold)
                    .onClick(() => {
                        this.message6 = b.getvalue4().toString()
                    });
            }.width('100 %')
        }.height('100 %')
    }
}

更多关于HarmonyOS 鸿蒙Next中MSI大型项目里需要在调用时操作大量类的实例化的实战系列教程也可以访问 https://www.itying.com/category-93-b0.html

gougou168 2楼

在HarmonyOS鸿蒙Next中，MSI大型项目需要在调用时操作大量类的实例化，可以通过以下方式实现：

使用Factory模式：Factory模式可以封装对象的创建过程，避免直接调用构造函数，便于集中管理和扩展。
依赖注入：通过依赖注入框架，自动管理对象的生命周期和依赖关系，减少手动实例化的代码量。
对于频繁创建和销毁的对象，使用对象池技术复用对象，减少实例化开销。
对于全局唯一对象，使用单例模式确保只创建一个实例，避免重复创建。
将系统拆分为多个模块，每个模块负责特定功能，减少单个模块的实例化负担。
对于复杂对象的创建，使用Builder模式分步构建对象，简化实例化过程。
对于经常使用的对象，使用缓存机制存储已实例化对象，减少重复创建。
在需要时才进行对象实例化，减少初始化时的资源消耗。
通过容器管理对象的生命周期和依赖关系，简化实例化过程。
通过优化类设计和减少不必要的依赖，降低实例化复杂性。

在鸿蒙系统中，这些方法可以帮助高效管理大量类的实例化，提升系统性能和可维护性。

bupafengyu 3楼

在HarmonyOS鸿蒙Next的MSI大型项目中，若需在调用时操作大量类的实例化，建议采用对象池（Object Pool）设计模式。对象池通过预先创建并管理一组可重用对象，减少频繁实例化带来的性能开销。同时，结合依赖注入框架（如Dagger或Hilt）可以进一步优化对象的生命周期管理和依赖关系，提升代码的可维护性和扩展性。此外，合理使用单例模式和懒加载策略也能有效减少资源消耗，确保系统的高效运行。