@fastcar/core 0.2.60 → 0.2.61

package/target/src/FastCarApplication.js

@@ -0,0 +1,704 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var FastCarApplication_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const fs = require("fs");
+const process = require("process");
+const Events = require("events");
+const path = require("path");
+const ClassLoader_1 = require("./utils/ClassLoader");
+const FileUtil_1 = require("./utils/FileUtil");
+const Mix_1 = require("./utils/Mix");
+const TypeUtil_1 = require("./utils/TypeUtil");
+const SysConfig_1 = require("./config/SysConfig");
+const FastCarMetaData_1 = require("./constant/FastCarMetaData");
+const CommonConstant_1 = require("./constant/CommonConstant");
+const LifeCycleModule_1 = require("./constant/LifeCycleModule");
+const AppStatusEnum_1 = require("./constant/AppStatusEnum");
+const ValidationUtil_1 = require("./utils/ValidationUtil");
+const Component_1 = require("./annotation/stereotype/Component");
+const WinstonLogger_1 = require("./model/WinstonLogger");
+const winston = require("winston");
+const DateUtil_1 = require("./utils/DateUtil");
+const Log_1 = require("./annotation/stereotype/Log");
+let FastCarApplication = FastCarApplication_1 = class FastCarApplication extends Events {
+    componentMap; //组件键值对
+    sysConfig; //系统配置
+    basePath; //入口文件夹路径
+    baseFileName; //入口文件路径
+    loggerFactory;
+    applicationStatus;
+    sysLogger;
+    componentDeatils; //读取路径  名称
+    liveTime;
+    watchFiles;
+    resourcePath = ""; //资源路径
+    delayHotIds;
+    reloadTimerId;
+    basename = CommonConstant_1.CommonConstant.Application;
+    constructor() {
+        super();
+        this.sysConfig = SysConfig_1.SYSDefaultConfig;
+        this.componentMap = new Map();
+        this.componentDeatils = new Map();
+        this.applicationStatus = AppStatusEnum_1.AppStatusEnum.READY;
+        this.liveTime = Date.now();
+        this.watchFiles = new Map();
+        this.delayHotIds = new Map();
+        this.reloadTimerId = null;
+        this.loadSelf();
+        this.addHot();
+    }
+    /***
+     * @version 1.0 根据原型加载注入的方法
+     *
+     */
+    getInjectionUniqueKey(target) {
+        let key = Reflect.getMetadata(FastCarMetaData_1.FastCarMetaData.InjectionUniqueKey, target);
+        return key;
+    }
+    loadSelf() {
+        let key = this.getInjectionUniqueKey(FastCarApplication_1);
+        this.componentMap.set(key, this);
+        this.componentDeatils.set("FastCarApplication", {
+            id: key,
+            name: "FastCarApplication",
+            path: __filename,
+        });
+        //暴露一个全局的app 以便调用
+        Reflect.set(global, CommonConstant_1.CommonConstant.FastcarApp, this);
+    }
+    /***
+     * @version 1.0 热更新组件
+     * @version 1.1 热更新配置文件
+     */
+    addHot() {
+        this.on("reload", (fp) => {
+            if (this.applicationStatus != AppStatusEnum_1.AppStatusEnum.RUN) {
+                return;
+            }
+            this.addDelayHot(fp, 1);
+        });
+        this.on("sysReload", (fp) => {
+            if (fp.indexOf(this.basename) != -1) {
+                this.addDelayHot(fp, 2);
+            }
+        });
+    }
+    addDelayHot(fp, loadType) {
+        if (this.delayHotIds.has(fp)) {
+            return;
+        }
+        this.delayHotIds.set(fp, {
+            fp,
+            loadType,
+        });
+        if (!this.reloadTimerId) {
+            this.reloadTimerId = setTimeout(() => {
+                this.reloadFiles();
+            }, 1000);
+        }
+    }
+    reloadFiles() {
+        this.delayHotIds.forEach(({ fp, loadType }) => {
+            switch (loadType) {
+                case 1: {
+                    let moduleClass = ClassLoader_1.default.loadModule(fp, true);
+                    this.sysLogger.info("hot update---" + fp);
+                    if (moduleClass != null) {
+                        moduleClass.forEach((func) => {
+                            this.convertInstance(func, fp);
+                        });
+                    }
+                    break;
+                }
+                case 2: {
+                    this.sysLogger.info("sysConfig hot update----" + fp);
+                    this.loadSysConfig();
+                    break;
+                }
+                default: {
+                }
+            }
+        });
+        this.delayHotIds.clear();
+        this.reloadTimerId = null;
+    }
+    /***
+     * @version 1.0 获取资源路径
+     */
+    getResourcePath() {
+        if (!!this.resourcePath) {
+            return this.resourcePath;
+        }
+        let resourcePath = path.join(this.basePath, "../", CommonConstant_1.CommonConstant.Resource);
+        this.resourcePath = resourcePath;
+        return resourcePath;
+    }
+    /***
+     * @version 1.0 获取项目的基本路径
+     *
+     */
+    getBasePath() {
+        return this.basePath;
+    }
+    /**
+     * @version 1.0 获取项目读取的基本配置路径
+     */
+    getBaseName() {
+        return this.basename;
+    }
+    /***
+     * @version 1.0 加载系统配置 加载顺序为 default json < yaml < env
+     *
+     */
+    loadSysConfig() {
+        this.sysConfig = FileUtil_1.default.getApplicationConfig(this.getResourcePath(), this.basename, this.sysConfig);
+        let env = (Reflect.get(this, CommonConstant_1.CommonConstant.ENV) || this.sysConfig.application.env || "devlopment");
+        this.sysConfig = FileUtil_1.default.getApplicationConfig(this.getResourcePath(), `${this.basename}-${env}`, this.sysConfig);
+        //自定义环境变量设置
+        process.env.NODE_ENV = env;
+        //判断程序内是否有配置
+        let applicationSesstings = Reflect.getMetadata(CommonConstant_1.CommonConstant.FastcarSetting, this);
+        if (applicationSesstings) {
+            applicationSesstings.forEach((value, key) => {
+                let afterConfig = value;
+                let beforeConfig = this.sysConfig.settings.get(key);
+                if (beforeConfig) {
+                    //对settings的属性进行覆盖
+                    if (typeof beforeConfig == "object") {
+                        afterConfig = Object.assign(beforeConfig, afterConfig);
+                    }
+                }
+                this.sysConfig.settings.set(key, afterConfig);
+            });
+        }
+        //读取app的必要信息 name和版本号 根据 package.json
+        let packagePath = path.join(this.basePath, "../", "package.json");
+        if (fs.existsSync(packagePath)) {
+            let packageInfo = require(packagePath);
+            if (packageInfo.name) {
+                this.sysConfig.application.name = packageInfo.name;
+            }
+            if (packageInfo.version) {
+                this.sysConfig.application.version = packageInfo.version;
+            }
+        }
+    }
+    setSetting(key, value) {
+        this.sysConfig.settings.set(key, value);
+    }
+    /***
+     * @version 1.0 获取自定义设置 设置优先级 配置自定义>系统配置>初始化
+     *
+     */
+    getSetting(key) {
+        let res = this.sysConfig.settings.get(key);
+        if (ValidationUtil_1.default.isNotNull(res)) {
+            return res;
+        }
+        res = Reflect.get(this.sysConfig, key);
+        if (ValidationUtil_1.default.isNotNull(res)) {
+            res;
+        }
+        return Reflect.get(this, key);
+    }
+    /***
+     * @version 1.0 获取应用配置
+     */
+    getapplicationConfig() {
+        return this.sysConfig.application;
+    }
+    /***
+     * @version 1.0 扫描组件
+     * @version 1.1 新增手动注入组件
+     * @version 1.2 改成统一入口
+     */
+    loadClass() {
+        //加载文件扫描下的bean
+        let tmpFilePath = Array.of();
+        let includeList = Reflect.get(this, FastCarMetaData_1.FastCarMetaData.ComponentScan) || [];
+        let mustIncludMustList = Reflect.get(this, FastCarMetaData_1.FastCarMetaData.ComponentScanMust) || [];
+        //从配置文件内读
+        if (Array.isArray(this.sysConfig.application?.scan?.include) && this.sysConfig.application?.scan?.include) {
+            includeList = [...includeList, ...this.sysConfig.application.scan.include];
+        }
+        if (includeList.length > 0) {
+            includeList.forEach((item) => {
+                //获取路径
+                let tmpList = FileUtil_1.default.getFilePathList(item);
+                tmpFilePath = tmpFilePath.concat(tmpList);
+            });
+        }
+        let includeFinalList = [];
+        mustIncludMustList.forEach((item) => {
+            let tmpList = FileUtil_1.default.getFilePathList(item);
+            includeFinalList = includeFinalList.concat(tmpList);
+        });
+        let filePathList = FileUtil_1.default.getFilePathList(this.basePath);
+        filePathList = tmpFilePath.concat(filePathList);
+        filePathList = [...new Set(filePathList)];
+        let excludeList = Reflect.get(this, FastCarMetaData_1.FastCarMetaData.ComponentScanExclusion) || [];
+        if (Array.isArray(this.sysConfig.application?.scan?.exclude) && this.sysConfig.application?.scan?.exclude) {
+            excludeList = [...excludeList, ...this.sysConfig.application.scan.exclude];
+        }
+        if (excludeList.length > 0) {
+            let excludAllPath = [];
+            excludeList.forEach((item) => {
+                let exlist = FileUtil_1.default.getFilePathList(item);
+                excludAllPath = [...excludAllPath, ...exlist];
+            });
+            filePathList = filePathList.filter((item) => {
+                if (includeFinalList.includes(item)) {
+                    return true;
+                }
+                return !excludAllPath.includes(item);
+            });
+        }
+        let resp = this.getResourcePath();
+        for (let f of filePathList) {
+            if (f == this.baseFileName) {
+                continue;
+            }
+            //如果是资源路径下的则自动过滤掉
+            if (f.startsWith(resp)) {
+                continue;
+            }
+            let moduleClass = ClassLoader_1.default.loadModule(f);
+            if (moduleClass != null) {
+                moduleClass.forEach((func, name) => {
+                    if (this.componentMap.has(name)) {
+                        let repeatError = new Error(`Duplicate ${name} instance objects are not allowed `);
+                        this.sysLogger.error(repeatError.message);
+                        throw repeatError;
+                    }
+                    this.convertInstance(func, f);
+                });
+            }
+        }
+    }
+    getInjectionUniqueKeyByFilePath(fp, name) {
+        let list = this.watchFiles.get(fp);
+        if (list) {
+            for (let item of list) {
+                if (item.name == name) {
+                    return item.key;
+                }
+            }
+        }
+        return null;
+    }
+    /***
+     * @version 1.0 转成实例对象
+     * @version 1.0.1 新增加载时识别载入配置选项
+     *
+     */
+    convertInstance(classZ, fp) {
+        //只有依赖注入的组件才能被实例化
+        let Target = classZ;
+        let instanceKey = Reflect.getMetadata(FastCarMetaData_1.FastCarMetaData.InjectionUniqueKey, classZ);
+        if (!instanceKey) {
+            Target = Reflect.get(classZ, "__target__");
+            if (!Target) {
+                return;
+            }
+            instanceKey = Reflect.getMetadata(FastCarMetaData_1.FastCarMetaData.InjectionUniqueKey, Target);
+        }
+        if (!!instanceKey) {
+            let iname = classZ?.name || FileUtil_1.default.getFileName(fp);
+            let beforeKey = this.getInjectionUniqueKeyByFilePath(fp, iname);
+            if (beforeKey) {
+                let beforeInstance = this.componentMap.get(beforeKey);
+                if (!!beforeInstance) {
+                    Mix_1.default.assign(beforeInstance, classZ);
+                    return;
+                }
+            }
+            //判断是否需要加载对应配置
+            let cp = Reflect.getMetadata(LifeCycleModule_1.LifeCycleModule.LoadConfigure, Target);
+            if (cp) {
+                let rfp = path.join(this.getResourcePath(), cp);
+                let tmpConfig = FileUtil_1.default.getResource(rfp);
+                //进行实例化赋值
+                if (tmpConfig) {
+                    //进行赋值不改变基础属性
+                    if (TypeUtil_1.default.isFunction(classZ)) {
+                        Mix_1.default.copPropertyValue(classZ.prototype, tmpConfig);
+                    }
+                    else {
+                        Mix_1.default.copPropertyValue(classZ, tmpConfig);
+                    }
+                }
+            }
+            let instance = TypeUtil_1.default.isFunction(classZ) ? new classZ() : classZ;
+            this.componentMap.set(instanceKey, instance);
+            this.componentDeatils.set(instanceKey, {
+                id: instanceKey,
+                name: classZ?.name || FileUtil_1.default.getFileName(fp),
+                path: fp,
+            });
+            //判断是否有别名
+            let aliasName = Reflect.getMetadata(FastCarMetaData_1.FastCarMetaData.Alias, instance);
+            if (aliasName) {
+                this.componentMap.set(aliasName, instance);
+                this.componentDeatils.set(aliasName, {
+                    id: aliasName,
+                    name: aliasName,
+                    path: fp,
+                });
+            }
+            //判断是否需要热更加载
+            if (this.isHotter() || Reflect.getMetadata(FastCarMetaData_1.FastCarMetaData.Hotter, instance)) {
+                let fpObj = this.watchFiles.get(fp);
+                let fpdesc = {
+                    key: instanceKey,
+                    name: iname,
+                };
+                if (!fpObj) {
+                    fpObj = [fpdesc];
+                    ClassLoader_1.default.watchServices(fp, this);
+                    this.watchFiles.set(fp, fpObj);
+                }
+                else {
+                    fpObj.push(fpdesc);
+                }
+            }
+        }
+    }
+    /***
+     * @version 1.0 装配模块
+     * @version 1.0 装配日志模块
+     * @version 1.1 移除装配日志模块 改为随用随取
+     * @deprecated 弃用系统自动装配
+     */
+    // injectionModule(instance: any, instanceName: string | symbol): void {
+    // 	let relyname = FastCarMetaData.IocModule;
+    // 	let moduleList: Map<string, string> = Reflect.getMetadata(relyname, instance);
+    // 	let detailInfo = this.componentDeatils.get(instanceName);
+    // 	if (moduleList && moduleList.size > 0) {
+    // 		moduleList.forEach((name: string, propertyKey: string) => {
+    // 			let func = this.componentMap.get(name);
+    // 			//如果等于自身则进行注入
+    // 			if (name === FastCarApplication.name || name === FastCarMetaData.APP) {
+    // 				func = this;
+    // 			} else {
+    // 				if (!this.componentMap.has(name)) {
+    // 					//找不到依赖项
+    // 					let injectionError = new Error(`Unsatisfied dependency expressed through [${propertyKey}] in ${detailInfo?.path} `);
+    // 					this.sysLogger.error(injectionError.message);
+    // 					throw injectionError;
+    // 				}
+    // 			}
+    // 			Reflect.set(instance, propertyKey, func);
+    // 		});
+    // 	}
+    // }
+    /**
+     * @version 1.0 加载需要注入的类
+     * @deprecated
+     */
+    // loadInjectionModule() {
+    // 	this.componentMap.forEach((instance, instanceName) => {
+    // 		//补充实例找不到时 不能被注解
+    // 		if (!instance) {
+    // 			let insatnceError = new Error(`instance not found by ${instanceName.toString()}`);
+    // 			this.sysLogger.error(insatnceError.message);
+    // 			throw insatnceError;
+    // 		}
+    // 		this.injectionModule(instance, instanceName);
+    // 	});
+    // }
+    /***
+     * @version 1.0 根据类型获取组件
+     */
+    getComponentByType(name) {
+        let instanceList = Array.of();
+        this.componentMap.forEach((instance) => {
+            let flag = Reflect.hasMetadata(name, instance);
+            if (flag) {
+                instanceList.push(instance);
+            }
+        });
+        return instanceList;
+    }
+    /***
+     * @version 1.0 获取全部的组件列表
+     */
+    getComponentList() {
+        return [...this.componentMap.values()];
+    }
+    /***
+     * @version 1.0 根据名称组件
+     */
+    getComponentByName(name) {
+        return this.componentMap.get(name);
+    }
+    /***
+     * @version 1.0 判断是否拥有组件名称
+     */
+    hasComponentByName(name) {
+        return this.componentMap.has(name);
+    }
+    /***
+     * @version 1.0 根据原型获取实例
+     */
+    getComponentByTarget(target) {
+        let key = this.getInjectionUniqueKey(target);
+        return this.componentMap.get(key);
+    }
+    /**
+     * @version 1.0 获取组件详情列表
+     *
+     */
+    getComponentDetailsList() {
+        return [...this.componentDeatils.values()];
+    }
+    /***
+     * @version 1.0 根据名称获取组件的加载情况
+     *
+     */
+    getComponentDetailByName(name) {
+        return this.componentDeatils.get(name);
+    }
+    /***
+     * @version 1.0 根据原型获取组件的加载信息
+     *
+     */
+    getComponentDetailByTarget(target) {
+        let key = this.getInjectionUniqueKey(target);
+        return this.componentDeatils.get(key);
+    }
+    /**
+     * @version 1.0 开启日志系统
+     * @version 1.1 更改为采用winston日志
+     */
+    startLog() {
+        let logConfig = this.getSetting("log");
+        let defaultConfig = Object.assign({}, SysConfig_1.LogDefaultConfig, { rootPath: path.join(this.basePath, "../logs") });
+        if (logConfig) {
+            Object.assign(defaultConfig, logConfig);
+        }
+        this.loggerFactory = new WinstonLogger_1.default(defaultConfig);
+        //添加系统日志
+        // this.sysLogger = this.loggerFactory.addLogger(CommonConstant.SYSLOGGER);
+    }
+    /***
+     * @version 1.0 初始化应用
+     */
+    init() {
+        //加载配置
+        this.basePath = (Reflect.get(this, CommonConstant_1.CommonConstant.BasePath) || require.main?.path || module.path || process.cwd());
+        this.baseFileName = (Reflect.get(this, CommonConstant_1.CommonConstant.BaseFileName) || require.main?.filename || module.filename);
+        this.beforeStartServer();
+        this.startServer();
+        this.addExitEvent();
+        this.addExecptionEvent();
+    }
+    async exitEvent(msg) {
+        //防止多次停止 原则上不会发生
+        if (this.applicationStatus == AppStatusEnum_1.AppStatusEnum.RUN) {
+            this.applicationStatus = AppStatusEnum_1.AppStatusEnum.STOP;
+            this.sysLogger.info("exit reason", msg);
+            await this.beforeStopServer();
+            process.exit();
+        }
+    }
+    addExitEvent() {
+        process.on("beforeExit", () => {
+            this.exitEvent("beforeExit exit");
+        });
+        process.on("SIGINT", () => {
+            this.exitEvent("sigint exit");
+        });
+        process.on("message", async (msg) => {
+            if (msg == "shutdown") {
+                this.exitEvent("shutdown");
+            }
+        });
+        process.on("exit", () => {
+            this.stopServer();
+        });
+    }
+    addExecptionEvent() {
+        process.on("uncaughtException", (err, origin) => {
+            this.sysLogger.error(`Caught exception: ${err.message}`);
+            this.sysLogger.error(`Exception origin: ${origin}`);
+            this.sysLogger.error(`stack: ${err.stack}`);
+        });
+        process.on("unhandledRejection", (reason, promise) => {
+            this.sysLogger.error("Unhandled Rejection at:", promise);
+            this.sysLogger.error("reason:", reason);
+        });
+    }
+    /***
+     * @version 1.0 自动调用方法
+     */
+    async automaticRun(name) {
+        let list = [];
+        this.componentMap.forEach((item) => {
+            let runInfo = Reflect.hasMetadata(name, item);
+            if (runInfo) {
+                let childList = Reflect.getMetadata(name, item);
+                childList.forEach((citem) => {
+                    list.push({
+                        order: citem.order,
+                        exec: citem.exec,
+                        item,
+                    });
+                });
+            }
+        });
+        list.sort((a, b) => {
+            return a.order - b.order;
+        });
+        for (let { exec, item } of list) {
+            let fn = item[exec];
+            if (TypeUtil_1.default.isPromise(fn)) {
+                await Promise.resolve(Reflect.apply(fn, item, []));
+            }
+            else {
+                Reflect.apply(fn, item, []);
+            }
+        }
+    }
+    /**
+     * @version 1.0 开启应用前执行的操作 加载配置,扫描组件，注入依赖组件
+     */
+    beforeStartServer() {
+        //加载日志
+        this.loadSysConfig();
+        //监听系统配置
+        if (this.isHotterSysConfig()) {
+            ClassLoader_1.default.watchServices(this.getResourcePath(), this, "sysReload");
+        }
+        //开启日志
+        this.startLog();
+        this.sysLogger.info("Start scanning component");
+        this.loadClass();
+        this.sysLogger.info("Complete component scan");
+        // this.sysLogger.info("Start component injection");
+        // this.loadInjectionModule();
+        // this.sysLogger.info("Complete component injection");
+    }
+    /***
+     * @version 1.0 启动服务
+     */
+    async startServer() {
+        this.sysLogger.info("Call application initialization method");
+        await this.automaticRun(LifeCycleModule_1.LifeCycleModule.ApplicationStart);
+        this.sysLogger.info(`start server ${this.sysConfig.application.name} is run`);
+        this.sysLogger.info(`version ${this.sysConfig.application.version}`);
+        this.applicationStatus = AppStatusEnum_1.AppStatusEnum.RUN;
+        if (process.send && TypeUtil_1.default.isFunction(process.send)) {
+            process.send("ready");
+        }
+    }
+    /***
+     * @version 1.0 停止服务前自动调用服务
+     */
+    async beforeStopServer() {
+        this.sysLogger.info("Call the method before the application stops");
+        await this.automaticRun(LifeCycleModule_1.LifeCycleModule.ApplicationStop);
+    }
+    /***
+     * @version 1.0 停止服务
+     */
+    stopServer() {
+        this.sysLogger.info("application stop");
+    }
+    /**
+     * @version 1.0 获取app名称
+     */
+    getApplicationName() {
+        return this.sysConfig.application.name;
+    }
+    /***
+     * @version 1.0 获取系统日志
+     *
+     */
+    getSysLogger() {
+        return this.sysLogger;
+    }
+    /***
+     * @version 1.0 获取文件内容
+     */
+    getFileContent(fp) {
+        if (!fs.existsSync(fp)) {
+            fp = path.join(this.getResourcePath(), fp);
+            if (!fs.existsSync(fp)) {
+                return "";
+            }
+        }
+        let currStats = fs.statSync(fp);
+        if (!currStats.isFile()) {
+            return "";
+        }
+        return fs.readFileSync(fp).toString();
+    }
+    /***
+     * @version 1.0 是否支持热更
+     *
+     */
+    isHotter() {
+        return !!this.getSetting("hotter");
+    }
+    /***
+     * @version 1.0 是否支持资源文件热更
+     */
+    isHotterSysConfig() {
+        return !!this.getSetting(FastCarMetaData_1.FastCarMetaData.HotterSysConfig);
+    }
+    /***
+     * @version 1.0 指定热更新文件
+     *
+     */
+    specifyHotUpdate(fp) {
+        if (fs.existsSync(fp)) {
+            this.emit("reload", fp);
+        }
+    }
+    /***
+     * @version 1.0 获取进程的信息
+     *
+     */
+    getMemoryUsage() {
+        let { rss, heapTotal, heapUsed, arrayBuffers, external } = process.memoryUsage();
+        return {
+            pid: process.pid,
+            name: this.sysConfig.application.name,
+            env: this.sysConfig.application.env,
+            version: this.sysConfig.application.version,
+            rss: FileUtil_1.default.formatBytes(rss),
+            heapTotal: FileUtil_1.default.formatBytes(heapTotal),
+            heapUsed: FileUtil_1.default.formatBytes(heapUsed),
+            arrayBuffers: FileUtil_1.default.formatBytes(arrayBuffers),
+            external: FileUtil_1.default.formatBytes(external),
+            uptime: DateUtil_1.default.getTimeStr(Date.now() - this.liveTime), //运行时间
+        };
+    }
+    getLogger(category = CommonConstant_1.CommonConstant.SYSLOGGER) {
+        let logger = this.loggerFactory.getLogger(category);
+        if (!logger) {
+            return this.loggerFactory.addLogger(category);
+        }
+        return logger;
+    }
+};
+__decorate([
+    (0, Log_1.default)("sys"),
+    __metadata("design:type", winston.Logger)
+], FastCarApplication.prototype, "sysLogger", void 0);
+FastCarApplication = FastCarApplication_1 = __decorate([
+    Component_1.default,
+    __metadata("design:paramtypes", [])
+], FastCarApplication);
+exports.default = FastCarApplication;