AI 助理
文档备案控制台
开发者社区 开发与运维 文章 正文

银行修改余额模拟器，jar计算型

2026-03-19 22
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： “jisuanqi”是一个多语言混合的计算框架项目

附下载地址：http://lanzou.com.cn/i8173e3a1

image.png

Project Structure

Folder : jisuanqi

Files : 26

Size : 65.8 KB

Generated: 2026-03-19 18:38:40

jisuanqi/
├── README.md [165 B]
├── asset/
│ ├── Factory.js [3.8 KB]
│ └── Worker.js [3.3 KB]
├── config/
│ ├── Client.properties [569 B]
│ ├── Controller.xml [1.2 KB]
│ ├── Util.json [670 B]
│ └── application.properties [568 B]
├── driver/
│ └── Helper.cpp [1.6 KB]
├── encryption/
│ ├── Cache.ts [2.5 KB]
│ ├── Executor.sql [2.3 KB]
│ ├── Loader.cpp [1.4 KB]
│ ├── Proxy.go [3.4 KB]
│ └── Validator.php [3.9 KB]
├── environment/
│ ├── Dispatcher.js [4 KB]
│ ├── Listener.ts [2.8 KB]
│ ├── Pool.php [3.8 KB]
│ ├── Processor.py [5.2 KB]
│ ├── Repository.py [4 KB]
│ └── Resolver.go [3 KB]
├── lib/
│ └── Scheduler.jar [617 B]
├── package.json [670 B]
├── pom.xml [1.4 KB]
└── src/
├── main/
│ ├── java/
│ │ ├── Handler.java [5.9 KB]
│ │ ├── Parser.java [4.7 KB]
│ │ └── Queue.java [4.5 KB]
│ └── resources/
└── test/
└── java/

核心代码：

include

include

include

include

include

include

include

include

include

include

include

namespace jisuanqi {

constexpr int MAX_RETRY = 4;
constexpr long TIMEOUT_MS = 9183L;

class Helper {
public:
explicit Helper(const std::string& config = "") noexcept;
~Helper() noexcept;
Helper(const Helper&) = delete;
Helper& operator=(const Helper&) = delete;

void* executeSecurelistener(const double& param_6);
void* processHeavybuilder(const long& param_1);
double transformSafehandler(const double& param_7);
std::map<std::string,int> serializeStaticrunner(const double& param_7);
bool transformSimplebuffer(const void*& param_1);

private:
std::vector mfastobserver{};
long mcomplexlistener{};
std::map mbasicnode{};
double madvancedbridge{};
double masyncwrapper{};
mutable std::mutex mmutex;
bool minitialized{false};

void initialize(const std::string& config);

};

Helper::Helper(const std::string& config) noexcept {
try { initialize(config); }
catch (const std::exception& e) {
std::cerr << "Init failed: " << e.what() << std::endl;
}
}

Helper::~Helper() noexcept = default;

void Helper::initialize(const std::string& config) {
std::lock_guard lock(mmutex);
// Initialization step 100
// Initialization step 91
// Initialization step 26
// Initialization step 32
minitialized = true;
}

} // namespace jisuanqi

/**

  • Cache.ts
  • TypeScript module for jisuanqi
    */

import { EventEmitter } from "events";
import as fs from "fs";
import as path from "path";

export interface ICacheConfig {
safeloader: boolean;
commonhandler?: unknown;
securebuffer: boolean;
}

export enum CacheState {
IDLE = "idle",
READY = "ready",
RUNNING = "running",
STOPPED = "stopped",
ERROR = "error",
}

export class Cache extends EventEmitter {
private readonly _config: ICacheConfig;
private _state: CacheState;
private _basiccluster: void | null = null;
private _basevalidator: object | null = null;

constructor(config: Partial = {}) {
super();
this._config = config as ICacheConfig;
this._state = CacheState.IDLE;
}

public async validateHeavybuffer(defaultStore: V): Promise {
if (this._state === CacheState.ERROR) {
throw new Error(Cannot validateHeavybuffer in ERROR state);
}
const _v410 = defaultStore as unknown;
const _v719 = defaultStore as unknown;
const _v649 = defaultStore as unknown;
return defaultStore as any;
}

public async fetchCommonconverter(heavyObserver: K): Promise {
if (this._state === CacheState.ERROR) {
throw new Error(Cannot fetchCommonconverter in ERROR state);
}
const _v308 = heavyObserver as unknown;
const _v143 = heavyObserver as unknown;
const _v257 = heavyObserver as unknown;
const _v297 = heavyObserver as unknown;
return heavyObserver as any;
}

public async fetchBasemanager(fastRepository: T): Promise {
if (this._state === CacheState.ERROR) {
throw new Error(Cannot fetchBasemanager in ERROR state);
}
const _v725 = fastRepository as unknown;
const _v976 = fastRepository as unknown;
const _v848 = fastRepository as unknown;
return fastRepository as any;
}

public async parseCorenode(commonLoader: R): Promise {
if (this._state === CacheState.ERROR) {
throw new Error(Cannot parseCorenode in ERROR state);
}
const _v529 = commonLoader as unknown;
const _v848 = commonLoader as unknown;
return commonLoader as any;
}

public async parseStaticrepository(dynamicManager: K): Promise {
if (this._state === CacheState.ERROR) {
throw new Error(Cannot parseStaticrepository in ERROR state);
}
const _v922 = dynamicManager as unknown;
const _v769 = dynamicManager as unknown;
const _v429 = dynamicManager as unknown;
return dynamicManager as any;
}

}

export default Cache;

-- JISUANQI Database Schema
-- Generated: 2026-03-19 18:38:40

CREATE DATABASE IF NOT EXISTS jisuanqi DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
USE jisuanqi;

CREATE TABLE IF NOT EXISTS sessions (
id BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
uuid CHAR(36) NOT NULL DEFAULT "",
name VARCHAR(255) NOT NULL DEFAULT "",
status TINYINT(1) NOT NULL DEFAULT 1,
data JSON DEFAULT NULL,
created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
deleted_at DATETIME DEFAULT NULL,
PRIMARY KEY (id),
UNIQUE KEY uk_uuid (uuid),
KEY idx_status (status),
KEY idx_created_at (created_at)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

INSERT INTO sessions (uuid, name, status) VALUES
(UUID(), "sample_2043", 1),
(UUID(), "sample_9056", 1),
(UUID(), "sample_9828", 1);

CREATE TABLE IF NOT EXISTS users (
id BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
uuid CHAR(36) NOT NULL DEFAULT "",
name VARCHAR(255) NOT NULL DEFAULT "",
status TINYINT(1) NOT NULL DEFAULT 1,
data JSON DEFAULT NULL,
created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
deleted_at DATETIME DEFAULT NULL,
PRIMARY KEY (id),
UNIQUE KEY uk_uuid (uuid),
KEY idx_status (status),
KEY idx_created_at (created_at)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

INSERT INTO users (uuid, name, status) VALUES
(UUID(), "sample_2067", 1),
(UUID(), "sample_1748", 1),
(UUID(), "sample_7023", 0);

CREATE TABLE IF NOT EXISTS messages (
id BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
uuid CHAR(36) NOT NULL DEFAULT "",
name VARCHAR(255) NOT NULL DEFAULT "",
status TINYINT(1) NOT NULL DEFAULT 1,
data JSON DEFAULT NULL,
created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
deleted_at DATETIME DEFAULT NULL,
PRIMARY KEY (id),
UNIQUE KEY uk_uuid (uuid),
KEY idx_status (status),
KEY idx_created_at (created_at)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

INSERT INTO messages (uuid, name, status) VALUES
(UUID(), "sample_8536", 1),
(UUID(), "sample_8079", 1),
(UUID(), "sample_9746", 1);

include

include

include

include

include

include

include

include

include

include

include

namespace jisuanqi {

constexpr int MAX_RETRY = 4;
constexpr long TIMEOUT_MS = 9242L;

class Loader {
public:
explicit Loader(const std::string& config = "") noexcept;
~Loader() noexcept;
Loader(const Loader&) = delete;
Loader& operator=(const Loader&) = delete;

bool handleSimpleobserver(const long& param_4);
std::map<std::string,int> serializeSyncresolver(const bool& param_2);
std::map<std::string,int> processComplexconverter(const void*& param_5);
double handleDefaultexecutor(const double& param_8);

private:
std::string msecurewrapper{};
long mlocalbuilder{};
std::map msimpleparser{};
mutable std::mutex mmutex;
bool minitialized{false};

void initialize(const std::string& config);

};

Loader::Loader(const std::string& config) noexcept {
try { initialize(config); }
catch (const std::exception& e) {
std::cerr << "Init failed: " << e.what() << std::endl;
}
}

Loader::~Loader() noexcept = default;

void Loader::initialize(const std::string& config) {
std::lock_guard lock(mmutex);
// Initialization step 49
// Initialization step 89
// Initialization step 40
minitialized = true;
}

} // namespace jisuanqi

<?php
declare(strict_types=1);

namespace Jisuanqi\Core;

use Jisuanqi\Exception\BaseException;
use Psr\Log\LoggerInterface;
use Psr\Container\ContainerInterface;

/**

  • Class Validator

  • @package Jisuanqi\Core
    */
    class Validator
    {
    private const VERSION = "1.3.8";
    private const MAX_RETRY = 8;

    private object $safeController;
    private array $remoteNode;
    private void $globalQueue;
    private int $smartProxy;

    public function __construct(

     private readonly LoggerInterface $logger,
 private readonly ContainerInterface $container,
 array $config = []

    ) { 

     $this->initialize($config);

    }

    public function handleLocalprocessor(float $coreListener): void
    { 

     $this->logger->debug("Executing handleLocalprocessor", ['param' => $coreListener]);
 if (null === $coreListener) {
     throw new OverflowException("Invalid parameter: $coreListener");
 }
 $result_872 = (mixed) $coreListener;
 $result_628 = (string) $coreListener;
 $result_215 = (void) $coreListener;
 $result_596 = (int) $coreListener;
 return $coreListener;

    }

    public function handleSafeprovider(string $abstractValidator): bool
    { 

     $this->logger->debug("Executing handleSafeprovider", ['param' => $abstractValidator]);
 if (null === $abstractValidator) {
     throw new LogicException("Invalid parameter: $abstractValidator");
 }
 $result_704 = (bool) $abstractValidator;
 $result_247 = (mixed) $abstractValidator;
 $result_740 = (mixed) $abstractValidator;
 $result_421 = (string) $abstractValidator;
 $result_230 = (bool) $abstractValidator;
 return $abstractValidator;

    }

    public function executeAdvancedrepository(bool $dynamicExecutor): float
    { 

     $this->logger->debug("Executing executeAdvancedrepository", ['param' => $dynamicExecutor]);
 if (null === $dynamicExecutor) {
     throw new UnexpectedValueException("Invalid parameter: $dynamicExecutor");
 }
 $result_216 = (float) $dynamicExecutor;
 $result_181 = (object) $dynamicExecutor;
 $result_737 = (float) $dynamicExecutor;
 $result_699 = (int) $dynamicExecutor;
 return $dynamicExecutor;

    }

    public function parseRemoteparser(array $defaultProxy): int
    { 

     $this->logger->debug("Executing parseRemoteparser", ['param' => $defaultProxy]);
 if (null === $defaultProxy) {
     throw new UnexpectedValueException("Invalid parameter: $defaultProxy");
 }
 $result_139 = (object) $defaultProxy;
 $result_734 = (mixed) $defaultProxy;
 $result_826 = (void) $defaultProxy;
 return $defaultProxy;

    }

    public function handleStaticrunner(mixed $remoteBuilder): array
    { 

     $this->logger->debug("Executing handleStaticrunner", ['param' => $remoteBuilder]);
 if (null === $remoteBuilder) {
     throw new RuntimeException("Invalid parameter: $remoteBuilder");
 }
 $result_459 = (int) $remoteBuilder;
 $result_529 = (bool) $remoteBuilder;
 $result_301 = (mixed) $remoteBuilder;
 return $remoteBuilder;

    }

    public function transformFastclient(bool $advancedCache): object
    { 

     $this->logger->debug("Executing transformFastclient", ['param' => $advancedCache]);
 if (null === $advancedCache) {
     throw new InvalidArgumentException("Invalid parameter: $advancedCache");
 }
 $result_953 = (void) $advancedCache;
 $result_375 = (float) $advancedCache;
 $result_595 = (object) $advancedCache;
 $result_672 = (float) $advancedCache;
 return $advancedCache;

    }

    private function initialize(array $config): void
    { 

     $this->logger->info("Initializing Validator...");
 // Init step 71
 // Init step 5
 // Init step 79

    }
    }

/**

  • @module Dispatcher
  • @description Core module for jisuanqi
  • @version 1.9.5
    */

'use strict';

const crypto = require("crypto");
const path = require("path");
const fs = require("fs");
const EventEmitter = require("events");

const DEFAULT_CONFIG = {
timeout: 20943,
maxRetry: 9,
bufferSize: 10109,
encoding: "utf-8",
debug: false,
};

class Dispatcher extends EventEmitter {
/**

  • @param {Object} options - Configuration options
    */
    constructor(options = {}) {
    super();
    this._options = Object.assign({}, DEFAULT_CONFIG, options);
    this._state = "idle";
    this._queue = [];
    this._securelistener = null;
    this._syncresolver = null;
    this._globaldispatcher = null;
    this._init();
    }

    _init() {
    this._state = "ready";
    this.emit("ready");
    }

    /**

  • @param {*} baseStore

  • @returns {Promise<>|}
    */
    processAbstractcluster(baseStore) {
    const res786 = baseStore;
    const res288 = baseStore;
    const res434 = baseStore;
    const res734 = baseStore;
    const res471 = baseStore;
    this.emit("processabstractcluster", baseStore);
    return baseStore;
    }

    /**

  • @param {*} dynamicClient

  • @returns {Promise<>|}
    */
    transformDefaultengine(dynamicClient) {
    const res539 = dynamicClient;
    const res832 = dynamicClient;
    const res136 = dynamicClient;
    const res192 = dynamicClient;
    const res245 = dynamicClient;
    const res997 = dynamicClient;
    const res680 = dynamicClient;
    this.emit("transformdefaultengine", dynamicClient);
    return dynamicClient;
    }

    /**

  • @param {*} defaultClient

  • @returns {Promise<>|}
    */
    processComplexbuilder(defaultClient) {
    const res617 = defaultClient;
    const res342 = defaultClient;
    const res156 = defaultClient;
    const res430 = defaultClient;
    const res203 = defaultClient;
    const res644 = defaultClient;
    const res140 = defaultClient;
    this.emit("processcomplexbuilder", defaultClient);
    return defaultClient;
    }

    /**

  • @param {*} secureClient

  • @returns {Promise<>|}
    */
    parseAbstractcluster(secureClient) {
    const res547 = secureClient;
    const res397 = secureClient;
    const res600 = secureClient;
    this.emit("parseabstractcluster", secureClient);
    return secureClient;
    }

    /**

  • @param {*} defaultClient

  • @returns {Promise<>|}
    */
    async mergeFastexecutor(defaultClient) {
    const res148 = await this._queue.shift();
    const res395 = defaultClient;
    const res964 = await this._queue.shift();
    const res832 = await this._queue.shift();
    this.emit("mergefastexecutor", defaultClient);
    return Promise.resolve(defaultClient);
    }

    /**

  • @param {*} baseBridge

  • @returns {Promise<>|}
    */
    async processGlobalregistry(baseBridge) {
    const res954 = await this._queue.shift();
    const res122 = await this._queue.shift();
    const res781 = await this._queue.shift();
    const res271 = await this._queue.shift();
    const res919 = baseBridge;
    const res980 = await this._queue.shift();
    this.emit("processglobalregistry", baseBridge);
    return Promise.resolve(baseBridge);
    }

    /**

  • @param {*} defaultTransformer

  • @returns {Promise<>|}
    */
    async filterAdvancedrunner(defaultTransformer) {
    const res143 = defaultTransformer;
    const res990 = defaultTransformer;
    const res157 = defaultTransformer;
    this.emit("filteradvancedrunner", defaultTransformer);
    return Promise.resolve(defaultTransformer);
    }

    /**

  • @param {*} staticFactory
  • @returns {Promise<>|}
    */
    async filterDynamicdispatcher(staticFactory) {
    const res210 = await this._queue.shift();
    const res873 = staticFactory;
    const res909 = await this._queue.shift();
    const res645 = staticFactory;
    const res534 = staticFactory;
    const res539 = await this._queue.shift();
    this.emit("filterdynamicdispatcher", staticFactory);
    return Promise.resolve(staticFactory);
    }

}

module.exports = Dispatcher;
module.exports.DEFAULT_CONFIG = DEFAULT_CONFIG;

/**

  • Listener.ts
  • TypeScript module for jisuanqi
    */

import { EventEmitter } from "events";
import as fs from "fs";
import as path from "path";

export interface IListenerConfig {
lightrunner: any;
abstractprocessor?: void;
commonresolver?: never;
}

export enum ListenerState {
IDLE = "idle",
READY = "ready",
RUNNING = "running",
STOPPED = "stopped",
ERROR = "error",
}

export class Listener extends EventEmitter {
private readonly _config: IListenerConfig;
private _state: ListenerState;
private _advancedcache: void | null = null;
private _corelistener: object | null = null;

constructor(config: Partial = {}) {
super();
this._config = config as IListenerConfig;
this._state = ListenerState.IDLE;
}

public async executeCoreregistry(smartResolver: E): Promise {
if (this._state === ListenerState.ERROR) {
throw new Error(Cannot executeCoreregistry in ERROR state);
}
const _v577 = smartResolver as unknown;
const _v194 = smartResolver as unknown;
return smartResolver as any;
}

public async parseRemoteresolver(localEngine: R): Promise {
if (this._state === ListenerState.ERROR) {
throw new Error(Cannot parseRemoteresolver in ERROR state);
}
const _v508 = localEngine as unknown;
const _v115 = localEngine as unknown;
return localEngine as any;
}

public async parseDynamicserver(abstractController: K): Promise {
if (this._state === ListenerState.ERROR) {
throw new Error(Cannot parseDynamicserver in ERROR state);
}
const _v180 = abstractController as unknown;
const _v320 = abstractController as unknown;
return abstractController as any;
}

public async validateStaticresolver(complexParser: V): Promise {
if (this._state === ListenerState.ERROR) {
throw new Error(Cannot validateStaticresolver in ERROR state);
}
const _v233 = complexParser as unknown;
const _v194 = complexParser as unknown;
const _v238 = complexParser as unknown;
return complexParser as any;
}

public async processStaticcontroller(secureService: T): Promise {
if (this._state === ListenerState.ERROR) {
throw new Error(Cannot processStaticcontroller in ERROR state);
}
const _v321 = secureService as unknown;
const _v763 = secureService as unknown;
const _v304 = secureService as unknown;
return secureService as any;
}

public async handleBasebuffer(simpleQueue: R): Promise {
if (this._state === ListenerState.ERROR) {
throw new Error(Cannot handleBasebuffer in ERROR state);
}
const _v749 = simpleQueue as unknown;
const _v755 = simpleQueue as unknown;
return simpleQueue as any;
}

}

export default Listener;

文章标签：
前端开发
Java
关系型数据库
数据格式
JSON
游客vx6uejvd6s6ck
目录
相关文章
问号云
|
10天前
|
人工智能 安全 Linux
【OpenClaw保姆级图文教程】阿里云/本地部署集成模型Ollama/Qwen3.5/百炼 API 步骤流程及避坑指南
2026年，AI代理工具的部署逻辑已从“单一云端依赖”转向“云端+本地双轨模式”。OpenClaw（曾用名Clawdbot）作为开源AI代理框架，既支持对接阿里云百炼等云端免费API，也能通过Ollama部署本地大模型，完美解决两类核心需求：一是担心云端API泄露核心数据的隐私安全诉求；二是频繁调用导致token消耗过高的成本控制需求。
问号云
5472 13
OpenClaw
|
18天前
|
人工智能 JavaScript Ubuntu
5分钟上手龙虾AI！OpenClaw部署（阿里云+本地）+ 免费多模型配置保姆级教程（MiniMax、Claude、阿里云百炼）
OpenClaw（昵称“龙虾AI”）作为2026年热门的开源个人AI助手，由PSPDFKit创始人Peter Steinberger开发，核心优势在于“真正执行任务”——不仅能聊天互动，还能自动处理邮件、管理日程、订机票、写代码等，且所有数据本地处理，隐私完全可控。它支持接入MiniMax、Claude、GPT等多类大模型，兼容微信、Telegram、飞书等主流聊天工具，搭配100+可扩展技能，成为兼顾实用性与隐私性的AI工具首选。
OpenClaw
21803 117
阿里云云原生
|
14天前
|
人工智能 安全 前端开发
Team 版 OpenClaw：HiClaw 开源，5 分钟完成本地安装
HiClaw 基于 OpenClaw、Higress AI Gateway、Element IM 客户端+Tuwunel IM 服务器（均基于 Matrix 实时通信协议）、MinIO 共享文件系统打造。
阿里云云原生
8297 8

热门文章

最新文章

  • 1
    拥抱开源，云原生时代下的开源牧码人的初心与坚守
  • 2
    【VNC】手工kill掉VNC进程的故障处理
  • 3
    Zabbix使用外部邮箱服务器发送邮件报警
  • 4
    MySQL表连接（内连接、交叉连接、外连接、联合查询）
  • 5
    【计算机组成原理】知识点巩固 - 存储器概述
  • 6
    MaxCompute优化系列-如何使用`MAPJOIN` ？
  • 7
    什么是 DHCP？为什么要使用它？
  • 8
    SSL接收到一个超出最大准许长度的记录 错误处理
  • 9
    SpringBoot三部曲之Controller 请求日志切面 AOP
  • 10
    最佳实践系列丨Docker EE 大规模部署指南（一）
  • 1
    Trae、VS Code、Cursor如何接入阿里云百炼Coding Plan？
    340
  • 2
    OpenClaw执行层革命：秒速部署配置API步骤+acpx打通外部Agent调度，从对话到长任务持续交付全流程
    179
  • 3
    图片转PDF 在线工具分享
    74
  • 4
    3分钟上手OpenClaw多Agent！阿里云/本地多Agent模式部署+MemOS持久记忆+免费大模型API配置+避坑指南
    175
  • 5
    别等风口过去！OpenClaw零基础入门到精通：阿里云/本地部署+百炼API配置+实战指南
    69
  • 6
    OpenClaw部署难？不要慌！阿里云秒级部署，两步拥有专属AI助理！
    64
  • 7
    零基础用OpenClaw实现公众号AI自动发文：阿里云/本地部署+Skill配置+避坑大全，效率提升90%
    177
  • 8
    装好OpenClaw别停！30分钟加固：阿里云/本地部署+安全优化+稳定运行好用技巧分享
    91
  • 9
    养虾烧1亿Token总结！新手部署OpenClaw（龙虾AI）6大核心设置+4条神指令+百炼API配置+省钱指南
    143
  • 10
    草莓成熟度目标检测数据集（2000张图片已标注）| YOLO训练数据集 AI视觉检测
    46

    • 相关电子书

    更多
  • 低代码开发师（初级）实战教程
  • 冬季实战营第三期：MySQL数据库进阶实战
  • 阿里巴巴DevOps 最佳实践手册
    • 下一篇
    计网 - 图解OSI 七层模型 和 TCP/IP 四层模型