鸿蒙金融理财全栈项目：基础架构、数据安全与用户体验

鸿蒙金融理财全栈项目：基础架构、数据安全与用户体验

一、金融理财项目架构基础

1.1 金融理财项目特点

金融理财项目具有以下特点：

• 高安全：需要严格的数据加密和身份认证；
• 高合规：需要符合金融监管要求；
• 高可用：需要保证应用的稳定运行；
• 高性能：需要快速响应用户的操作。

1.2 金融理财项目架构

金融理财项目采用分层架构，由以下部分组成：

• 用户界面层：负责用户的交互与界面渲染；
• 业务逻辑层：负责处理业务逻辑；
• 数据访问层：负责数据的存储与管理；
• 数据安全层：负责数据的加密、身份认证、安全审计；
• 服务接口层：负责与后端服务的通信。

二、金融理财项目架构实战

2.1 实战目标

基于金融场景的高安全、高合规、高性能要求，实现以下功能：

• 用户界面层：实现用户的交互与界面渲染；
• 业务逻辑层：处理金融理财的业务逻辑；
• 数据访问层：存储与管理金融数据；
• 数据安全层：加密数据、身份认证、安全审计；
• 服务接口层：与后端服务的通信。

2.2 用户界面层实现

1. 主页面布局

entry/src/main/ets/pages/MainPage.ets

@Entry
@Component
struct MainPage {
    @State selectedIndex: number = 0;
    build() {
        Column({ space: 0 }) {
            Stack({ alignContent: Alignment.Center }) {
                Column({ space: 8 }) {
                    Text('金融理财').fontSize(24).fontWeight(FontWeight.Bold).textColor('#000000');
                    Text('安全、合规、高效的理财平台').fontSize(14).textColor('#666666');
                }.width('100%').height('auto').padding(16).backgroundColor('#F5F5F5');
                Image('common/icons/security.png').width(60).height(60).objectFit(ImageFit.Cover).margin({ top: 8 });
            }.width('100%').height(120).backgroundColor('#F5F5F5');
            Tabs({ index: this.selectedIndex, vertical: false }) {
                TabContent() {
                    FinancialProductsPage();
                }.tabBar('理财产品');
                TabContent() {
                    PersonalFinancePage();
                }.tabBar('个人理财');
                TabContent() {
                    RiskAssessmentPage();
                }.tabBar('风险评估');
                TabContent() {
                    AccountManagementPage();
                }.tabBar('账户管理');
            }.width('100%').height('100%').backgroundColor('#F5F5F5').onChange((index: number) => {
                this.selectedIndex = index;
            });
        }.width('100%').height('100%').backgroundColor('#F5F5F5');
    }
}

2. 理财产品页面

entry/src/main/ets/pages/FinancialProductsPage.ets

@Entry
@Component
struct FinancialProductsPage {
    @State financialProducts: Array<financial.FinancialProduct> = [];
    build() {
        Column({ space: 16 }) {
            ListComponent({ data: this.financialProducts, renderItem: (item: financial.FinancialProduct, index: number) => {
                Row({ space: 16 }) {
                    Image(item.avatarUrl).width(80).height(80).objectFit(ImageFit.Cover).borderRadius(8);
                    Column({ space: 8 }) {
                        Text(item.name).fontSize(16).fontWeight(FontWeight.Bold).textColor('#000000');
                        Text(item.description).fontSize(14).textColor('#666666').maxLines(2).textOverflow({ overflow: TextOverflow.Ellipsis });
                        Text(`预期收益率：${item.expectedReturnRate}%`).fontSize(16).fontWeight(FontWeight.Bold).textColor('#FF0000');
                    }.layoutWeight(1);
                    ButtonComponent({ text: '查看详情', onClick: () => {
                        router.pushUrl({ url: '/pages/FinancialProductDetailPage', params: { productId: item.productId } });
                    }, disabled: false });
                }.width('100%').height('auto').padding(16).backgroundColor('#FFFFFF').borderRadius(8).margin({ bottom: 8 });
            }, onItemClick: (item: financial.FinancialProduct, index: number) => {
                router.pushUrl({ url: '/pages/FinancialProductDetailPage', params: { productId: item.productId } });
            }});
        }.width('100%').height('100%').padding(16).backgroundColor('#F5F5F5');
    }
    aboutToAppear() {
        this.initFinancialProducts();
    }
    async initFinancialProducts(): Promise<void> {
        this.financialProducts = await FinancialProductUtil.getInstance().getFinancialProducts();
    }
}

2.3 业务逻辑层实现

1. 金融产品工具类

entry/src/main/ets/utils/FinancialProductUtil.ets

import financial from '@ohos.financial';

export class FinancialProductUtil {
    private static instance: FinancialProductUtil | null = null;
    private financialHelper: financial.FinancialHelper | null = null;

    static getInstance(): FinancialProductUtil {
        if (!FinancialProductUtil.instance) {
            FinancialProductUtil.instance = new FinancialProductUtil();
        }
        return FinancialProductUtil.instance;
    }

    async init(): Promise<void> {
        if (!this.financialHelper) {
            this.financialHelper = financial.createFinancialHelper();
        }
    }

    async getFinancialProducts(): Promise<Array<financial.FinancialProduct>> {
        if (!this.financialHelper) {
            return [];
        }
        const result = await this.financialHelper.getFinancialProducts();
        return result;
    }

    async getFinancialProductDetail(productId: number): Promise<financial.FinancialProductDetail> {
        if (!this.financialHelper) {
            return null;
        }
        const result = await this.financialHelper.getFinancialProductDetail(productId);
        return result;
    }
}

2. 个人理财工具类

entry/src/main/ets/utils/PersonalFinanceUtil.ets

import personal from '@ohos.personal';

export class PersonalFinanceUtil {
    private static instance: PersonalFinanceUtil | null = null;
    private personalHelper: personal.PersonalHelper | null = null;

    static getInstance(): PersonalFinanceUtil {
        if (!PersonalFinanceUtil.instance) {
            PersonalFinanceUtil.instance = new PersonalFinanceUtil();
        }
        return PersonalFinanceUtil.instance;
    }

    async init(): Promise<void> {
        if (!this.personalHelper) {
            this.personalHelper = personal.createPersonalHelper();
        }
    }

    async getPersonalFinanceData(): Promise<personal.PersonalFinanceData> {
        if (!this.personalHelper) {
            return null;
        }
        const result = await this.personalHelper.getPersonalFinanceData();
        return result;
    }

    async purchaseFinancialProduct(productId: number, amount: number): Promise<personal.PurchaseFinancialProductResult> {
        if (!this.personalHelper) {
            return null;
        }
        const result = await this.personalHelper.purchaseFinancialProduct(productId, amount);
        return result;
    }
}

2.4 数据安全层实现

1. 数据加密工具类

entry/src/main/ets/utils/DataEncryptionUtil.ets

import encryption from '@ohos.encryption';

export class DataEncryptionUtil {
    private static instance: DataEncryptionUtil | null = null;
    private encryptionHelper: encryption.EncryptionHelper | null = null;

    static getInstance(): DataEncryptionUtil {
        if (!DataEncryptionUtil.instance) {
            DataEncryptionUtil.instance = new DataEncryptionUtil();
        }
        return DataEncryptionUtil.instance;
    }

    async init(): Promise<void> {
        if (!this.encryptionHelper) {
            this.encryptionHelper = encryption.createEncryptionHelper();
        }
    }

    async encryptData(data: string): Promise<string> {
        if (!this.encryptionHelper) {
            return null;
        }
        const result = await this.encryptionHelper.encryptData(data);
        return result;
    }

    async decryptData(encryptedData: string): Promise<string> {
        if (!this.encryptionHelper) {
            return null;
        }
        const result = await this.encryptionHelper.decryptData(encryptedData);
        return result;
    }
}

2. 身份认证工具类

entry/src/main/ets/utils/IdentityAuthenticationUtil.ets

import authentication from '@ohos.authentication';

export class IdentityAuthenticationUtil {
    private static instance: IdentityAuthenticationUtil | null = null;
    private authenticationHelper: authentication.AuthenticationHelper | null = null;

    static getInstance(): IdentityAuthenticationUtil {
        if (!IdentityAuthenticationUtil.instance) {
            IdentityAuthenticationUtil.instance = new IdentityAuthenticationUtil();
        }
        return IdentityAuthenticationUtil.instance;
    }

    async init(): Promise<void> {
        if (!this.authenticationHelper) {
            this.authenticationHelper = authentication.createAuthenticationHelper();
        }
    }

    async authenticate(): Promise<authentication.AuthenticationResult> {
        if (!this.authenticationHelper) {
            return null;
        }
        const result = await this.authenticationHelper.authenticate();
        return result;
    }

    async checkAuthenticationStatus(): Promise<authentication.AuthenticationStatus> {
        if (!this.authenticationHelper) {
            return null;
        }
        const result = await this.authenticationHelper.checkAuthenticationStatus();
        return result;
    }
}

2.5 服务接口层实现

1. 后端服务接口工具类

entry/src/main/ets/utils/BackendServiceUtil.ets

import http from '@ohos.net.http';

export class BackendServiceUtil {
    private static instance: BackendServiceUtil | null = null;
    private httpRequest: http.HttpRequest | null = null;

    static getInstance(): BackendServiceUtil {
        if (!BackendServiceUtil.instance) {
            BackendServiceUtil.instance = new BackendServiceUtil();
        }
        return BackendServiceUtil.instance;
    }

    async init(): Promise<void> {
        if (!this.httpRequest) {
            this.httpRequest = http.createHttp();
        }
    }

    async sendGetRequest(url: string): Promise<string> {
        if (!this.httpRequest) {
            return null;
        }
        const result = await this.httpRequest.request(url);
        return result.result as string;
    }

    async sendPostRequest(url: string, data: string): Promise<string> {
        if (!this.httpRequest) {
            return null;
        }
        const result = await this.httpRequest.request(url, {
            method: http.RequestMethod.POST,
            extraData: data,
            expectDataType: http.HttpDataType.STRING,
            usingCache: false,
            priority: http.RequestPriority.DEFAULT,
            connectTimeout: 60000,
            readTimeout: 60000
        });
        return result.result as string;
    }
}

三、数据安全实战

3.1 实战目标

基于金融场景的高安全要求，实现以下功能：

• 数据加密：加密用户的敏感数据；
• 身份认证：确保用户的身份真实性；
• 安全审计：记录用户的操作日志。

3.2 数据加密实现

在用户注册、登录、购买等操作中，对用户的敏感数据进行加密处理。

3.3 身份认证实现

1. 身份认证应用

entry/src/main/ets/pages/IdentityAuthenticationPage.ets

import { IdentityAuthenticationUtil } from '../utils/IdentityAuthenticationUtil';

@Entry
@Component
struct IdentityAuthenticationPage {
    @State authenticationResult: authentication.AuthenticationResult | null = null;
    build() {
        Column({ space: 16 }) {
            Text('身份认证').fontSize(18).fontWeight(FontWeight.Bold).textColor('#000000');
            ButtonComponent({ text: '进行身份认证', onClick: async () => {
                await this.authenticate();
            }, disabled: false });
            if (this.authenticationResult) {
                Text(`认证结果：${this.authenticationResult.success}`).fontSize(14).textColor('#000000');
                Text(`认证方式：${this.authenticationResult.authenticationMethod}`).fontSize(14).textColor('#666666');
            }
        }.width('100%').height('100%').padding(16).backgroundColor('#F5F5F5');
    }
    aboutToAppear() {
        IdentityAuthenticationUtil.getInstance().init();
    }
    async authenticate(): Promise<void> {
        this.authenticationResult = await IdentityAuthenticationUtil.getInstance().authenticate();
    }
}

3.4 安全审计实现

1. 安全审计工具类

entry/src/main/ets/utils/SecurityAuditUtil.ets

import audit from '@ohos.audit';

export class SecurityAuditUtil {
    private static instance: SecurityAuditUtil | null = null;
    private auditHelper: audit.AuditHelper | null = null;

    static getInstance(): SecurityAuditUtil {
        if (!SecurityAuditUtil.instance) {
            SecurityAuditUtil.instance = new SecurityAuditUtil();
        }
        return SecurityAuditUtil.instance;
    }

    async init(): Promise<void> {
        if (!this.auditHelper) {
            this.auditHelper = audit.createAuditHelper();
        }
    }

    async recordOperationLog(operationLog: audit.OperationLog): Promise<void> {
        if (!this.auditHelper) {
            return;
        }
        await this.auditHelper.recordOperationLog(operationLog);
    }

    async getOperationLog(): Promise<Array<audit.OperationLog>> {
        if (!this.auditHelper) {
            return [];
        }
        const result = await this.auditHelper.getOperationLog();
        return result;
    }
}

四、用户体验实战

4.1 实战目标

基于金融场景的用户体验要求，实现以下功能：

• 无障碍设计：确保应用对所有用户的可访问性；
• 响应式布局：适配不同屏幕尺寸的设备；
• 性能优化：提升应用的响应速度。

4.2 无障碍设计实现

1. 无障碍设计应用

entry/src/main/ets/pages/AccessibilityDesignPage.ets

@Entry
@Component
struct AccessibilityDesignPage {
    build() {
        Column({ space: 16 }) {
            Text('无障碍设计').fontSize(18).fontWeight(FontWeight.Bold).textColor('#000000');
            Text('我们的应用符合无障碍设计标准，确保所有用户都能正常使用。').fontSize(14).textColor('#666666');
            ButtonComponent({ text: '启用无障碍功能', onClick: async () => {
                await this.enableAccessibility();
            }, disabled: false });
        }.width('100%').height('100%').padding(16).backgroundColor('#F5F5F5');
    }
    async enableAccessibility(): Promise<void> {
        const accessibility = new accessibility.AccessibilityManager();
        await accessibility.enableAccessibility();
        promptAction.showToast({ message: '无障碍功能已启用' });
    }
}

4.3 响应式布局实现

1. 响应式布局应用

entry/src/main/ets/pages/ResponsiveLayoutPage.ets

@Entry
@Component
struct ResponsiveLayoutPage {
    build() {
        Column({ space: 16 }) {
            Text('响应式布局').fontSize(18).fontWeight(FontWeight.Bold).textColor('#000000');
            Text('我们的应用适配不同屏幕尺寸的设备，确保在任何设备上都能正常显示。').fontSize(14).textColor('#666666');
            Row({ space: 16 }) {
                Text('屏幕宽度：').fontSize(14).textColor('#000000');
                Text(`${px2vp(display.getDefaultDisplaySync().width)}`).fontSize(14).textColor('#666666');
            }.width('100%').height('auto');
            Row({ space: 16 }) {
                Text('屏幕高度：').fontSize(14).textColor('#000000');
                Text(`${px2vp(display.getDefaultDisplaySync().height)}`).fontSize(14).textColor('#666666');
            }.width('100%').height('auto');
        }.width('100%').height('100%').padding(16).backgroundColor('#F5F5F5');
    }
}

4.4 性能优化实现

1. 性能优化工具类

entry/src/main/ets/utils/PerformanceOptimizationUtil.ets

import performance from '@ohos.performance';

export class PerformanceOptimizationUtil {
    private static instance: PerformanceOptimizationUtil | null = null;
    private performanceHelper: performance.PerformanceHelper | null = null;

    static getInstance(): PerformanceOptimizationUtil {
        if (!PerformanceOptimizationUtil.instance) {
            PerformanceOptimizationUtil.instance = new PerformanceOptimizationUtil();
        }
        return PerformanceOptimizationUtil.instance;
    }

    async init(): Promise<void> {
        if (!this.performanceHelper) {
            this.performanceHelper = performance.createPerformanceHelper();
        }
    }

    async optimizePerformance(): Promise<performance.PerformanceResult> {
        if (!this.performanceHelper) {
            return null;
        }
        const result = await this.performanceHelper.optimizePerformance();
        return result;
    }
}

五、项目配置与部署

5.1 配置文件修改

在 entry/src/main/module.json5 中添加金融理财项目配置：

{
    "module": {
        "requestPermissions": [],
        "abilities": [],
        "widgets": [],
        "pages": []
    }
}

5.2 项目部署

1. 编译项目：在 DevEco Studio 中点击 Build → Build HAP，编译项目。
2. 部署到设备：将编译后的 HAP 文件部署到鸿蒙设备上。
3. 测试金融理财项目：验证金融产品列表、个人理财数据、风险评估、账户管理、身份认证、安全审计、无障碍设计、响应式布局及性能优化的效果。

六、项目运行与效果验证

• 金融产品列表：显示金融产品的名称、描述、预期收益率；
• 个人理财数据：显示用户的资产、收益、支出等信息；
• 风险评估：评估用户的风险承受能力；
• 账户管理：管理用户的账户信息；
• 身份认证：确保用户的身份真实性；
• 安全审计：记录用户的操作日志；
• 无障碍设计：确保应用对所有用户的可访问性；
• 响应式布局：适配不同屏幕尺寸的设备；
• 性能优化：提升应用的响应速度。