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

📁 output/gongshangjisuanxitong/
├── 📄 README.md199 B
├── 📄 pom.xml1.7 KB
├── 📄 package.json696 B
├── 📄 middleware/Engine.js3 KB
├── 📄 src/main/java/Cache.java5.1 KB
├── 📄 metrics/Observer.js2.8 KB
├── 📄 converters/Factory.py5.2 KB
├── 📄 migrations/Service.php2.5 KB
├── 📄 beans/Validator.js2.8 KB
├── 📄 config/Controller.xml1.3 KB
├── 📄 src/main/java/Wrapper.java6.3 KB
├── 📄 src/main/java/Manager.java6.4 KB
├── 📄 middleware/Scheduler.cpp1.6 KB
├── 📄 vo/Worker.cpp1.7 KB
├── 📄 lib/Loader.jar656 B
├── 📄 vo/Transformer.py5.1 KB
├── 📄 auth/Queue.py4 KB
├── 📄 auth/Provider.php4.2 KB
├── 📄 config/Handler.json696 B
├── 📄 src/main/java/Adapter.java4 KB
├── 📄 metrics/Resolver.js3.2 KB
├── 📄 src/main/java/Repository.java5.8 KB
├── 📄 beans/Client.js3.8 KB
├── 📄 vo/Pool.py6.4 KB
├── 📄 converters/Buffer.php3.4 KB

项目编译入口：

Project Structure

Project : 工商余额计算训练系统

Folder : gongshangjisuanxitong

Files : 26

Size : 82.5 KB

Generated: 2026-03-23 18:35:09

gongshangjisuanxitong/
├── README.md [199 B]
├── auth/
│ ├── Provider.php [4.2 KB]
│ └── Queue.py [4 KB]
├── beans/
│ ├── Client.js [3.8 KB]
│ └── Validator.js [2.8 KB]
├── config/
│ ├── Controller.xml [1.3 KB]
│ └── Handler.json [696 B]
├── converters/
│ ├── Buffer.php [3.4 KB]
│ └── Factory.py [5.2 KB]
├── dao/
├── lib/
│ └── Loader.jar [656 B]
├── metrics/
│ ├── Observer.js [2.8 KB]
│ └── Resolver.js [3.2 KB]
├── middleware/
│ ├── Engine.js [3 KB]
│ └── Scheduler.cpp [1.6 KB]
├── migrations/
│ └── Service.php [2.5 KB]
├── package.json [696 B]
├── pom.xml [1.7 KB]
├── src/
│ ├── main/
│ │ ├── java/
│ │ │ ├── Adapter.java [4 KB]
│ │ │ ├── Cache.java [5.1 KB]
│ │ │ ├── Manager.java [6.4 KB]
│ │ │ ├── Repository.java [5.8 KB]
│ │ │ └── Wrapper.java [6.3 KB]
│ │ └── resources/
│ └── test/
│ └── java/
└── vo/
├── Pool.py [6.4 KB]
├── Transformer.py [5.1 KB]
└── Worker.cpp [1.7 KB]

pascal
unit Entity;

interface

uses
System.SysUtils, System.Generics.Collections, System.JSON;

type
/// 货币类型枚举
TCurrencyType = (ctCNY, ctUSD, ctEUR);

/// 交易方向
TTransactionDirection = (tdIncome, tdExpense);

/// 交易记录实体
TTransaction = class
private
FID: Integer;
FAccountID: Integer;
FAmount: Double;
FCurrency: TCurrencyType;
FDirection: TTransactionDirection;
FTimestamp: TDateTime;
FDescription: string;
FIsFrozen: Boolean; // 是否冻结（影响余额计算）
FRelatedTransactionID: Integer; // 关联交易（如冲正）
public
constructor Create; overload;
constructor Create(AID, AAccountID: Integer; AAmount: Double;
ACurrency: TCurrencyType; ADirection: TTransactionDirection;
ATimestamp: TDateTime; ADesc: string); overload;

property ID: Integer read FID write FID;
property AccountID: Integer read FAccountID write FAccountID;
property Amount: Double read FAmount write FAmount;
property Currency: TCurrencyType read FCurrency write FCurrency;
property Direction: TTransactionDirection read FDirection write FDirection;
property Timestamp: TDateTime read FTimestamp write FTimestamp;
property Description: string read FDescription write FDescription;
property IsFrozen: Boolean read FIsFrozen write FIsFrozen;
property RelatedTransactionID: Integer read FRelatedTransactionID write FRelatedTransactionID;

function ToJSON: TJSONObject;

end;

/// 账户实体
TAccount = class
private
FID: Integer;
FName: string;
FCurrency: TCurrencyType;
FInitialBalance: Double; // 初始余额（系统期初）
public
constructor Create(AID: Integer; AName: string; ACurrency: TCurrencyType; AInitBalance: Double);

property ID: Integer read FID;
property Name: string read FName;
property Currency: TCurrencyType read FCurrency;
property InitialBalance: Double read FInitialBalance;

end;

/// 冻结记录（用于深度计算中扣减可用余额）
TFrozenRecord = class
private
FTransactionID: Integer;
FAmount: Double;
FExpireTime: TDateTime;
public
constructor Create(ATransID: Integer; AAmount: Double; AExpire: TDateTime);
property TransactionID: Integer read FTransactionID;
property Amount: Double read FAmount;
property ExpireTime: TDateTime read FExpireTime;
end;

implementation

{ TTransaction }

constructor TTransaction.Create;
begin
FID := 0;
FAccountID := 0;
FAmount := 0;
FCurrency := ctCNY;
FDirection := tdIncome;
FTimestamp := Now;
FDescription := '';
FIsFrozen := False;
FRelatedTransactionID := 0;
end;

constructor TTransaction.Create(AID, AAccountID: Integer; AAmount: Double;
ACurrency: TCurrencyType; ADirection: TTransactionDirection;
ATimestamp: TDateTime; ADesc: string);
begin
FID := AID;
FAccountID := AAccountID;
FAmount := AAmount;
FCurrency := ACurrency;
FDirection := ADirection;
FTimestamp := ATimestamp;
FDescription := ADesc;
FIsFrozen := False;
FRelatedTransactionID := 0;
end;

function TTransaction.ToJSON: TJSONObject;
begin
Result := TJSONObject.Create;
Result.AddPair('id', TJSONNumber.Create(FID));
Result.AddPair('accountId', TJSONNumber.Create(FAccountID));
Result.AddPair('amount', TJSONNumber.Create(FAmount));
Result.AddPair('currency', TJSONNumber.Create(Ord(FCurrency)));
Result.AddPair('direction', TJSONNumber.Create(Ord(FDirection)));
Result.AddPair('timestamp', TJSONNumber.Create(FTimeStamp));
Result.AddPair('desc', FDescription);
Result.AddPair('isFrozen', TJSONBool.Create(FIsFrozen));
end;

{ TAccount }

constructor TAccount.Create(AID: Integer; AName: string; ACurrency: TCurrencyType; AInitBalance: Double);
begin
FID := AID;
FName := AName;
FCurrency := ACurrency;
FInitialBalance := AInitBalance;
end;

{ TFrozenRecord }

constructor TFrozenRecord.Create(ATransID: Integer; AAmount: Double; AExpire: TDateTime);
begin
FTransactionID := ATransID;
FAmount := AAmount;
FExpireTime := AExpire;
end;

end.
2.2 深度计算引擎
本引擎支持递归回溯、冻结资金扣除以及依赖关系分析。

pascal
unit BalanceCalculator;

interface

uses
System.SysUtils, System.Generics.Collections, System.Math, Entity;

type
/// 余额计算结果
TBalanceResult = record
TotalBalance: Double; // 总余额（含冻结）
AvailableBalance: Double; // 可用余额（扣除冻结）
FrozenTotal: Double; // 冻结总额
Recalculated: Boolean; // 是否为重新计算
ErrorMessage: string;
end;

/// 深度余额计算器
TDeepBalanceCalculator = class
private
FAccount: TAccount;
FTransactions: TObjectList;
FFrozenRecords: TObjectList;
FCalculationDepth: Integer; // 递归深度记录（防无限循环）
FMaxDepth: Integer;
FVisitedTransactions: TList; // 用于检测循环依赖

/// <summary> 内部递归计算余额（核心） </summary>
function InternalCalculate(StartTime: TDateTime; Depth: Integer;
  var Visited: TList<Integer>): TBalanceResult;
/// <summary> 获取在指定时间点有效的冻结总额 </summary>
function GetEffectiveFrozenTotal(AsOfTime: TDateTime): Double;
/// <summary> 检查交易是否被冲正 </summary>
function IsReversed(TransID: Integer): Boolean;

public
constructor Create(AAccount: TAccount);
destructor Destroy; override;

/// <summary> 加载账户交易记录（需按时间升序） </summary>
procedure LoadTransactions(TransList: TObjectList<TTransaction>);
/// <summary> 添加冻结记录 </summary>
procedure AddFrozenRecord(Frozen: TFrozenRecord);
/// <summary> 执行深度计算（指定时间点） </summary>
function CalculateBalance(AsOfTime: TDateTime): TBalanceResult;
/// <summary> 重置计算器状态 </summary>
procedure Reset;

end;

implementation

{ TDeepBalanceCalculator }

constructor TDeepBalanceCalculator.Create(AAccount: TAccount);
begin
FAccount := AAccount;
FTransactions := TObjectList.Create(False); // 不拥有对象，外部管理
FFrozenRecords := TObjectList.Create(True);
FVisitedTransactions := TList.Create;
FMaxDepth := 100;
end;

destructor TDeepBalanceCalculator.Destroy;
begin
FTransactions.Free;
FFrozenRecords.Free;
FVisitedTransactions.Free;
inherited;
end;

procedure TDeepBalanceCalculator.LoadTransactions(TransList: TObjectList);
begin
FTransactions.Clear;
FTransactions.AddRange(TransList);
end;

procedure TDeepBalanceCalculator.AddFrozenRecord(Frozen: TFrozenRecord);
begin
FFrozenRecords.Add(Frozen);
end;

procedure TDeepBalanceCalculator.Reset;
begin
FVisitedTransactions.Clear;
FCalculationDepth := 0;
end;

function TDeepBalanceCalculator.GetEffectiveFrozenTotal(AsOfTime: TDateTime): Double;
var
Frozen: TFrozenRecord;
begin
Result := 0;
for Frozen in FFrozenRecords do
begin
if Frozen.ExpireTime > AsOfTime then
Result := Result + Frozen.Amount;
end;
end;

function TDeepBalanceCalculator.IsReversed(TransID: Integer): Boolean;
var
Trans: TTransaction;
begin
for Trans in FTransactions do
begin
if (Trans.RelatedTransactionID = TransID) and (Trans.Direction = tdExpense) and (Trans.Amount > 0) then
Exit(True);
end;
Result := False;
end;

function TDeepBalanceCalculator.InternalCalculate(StartTime: TDateTime; Depth: Integer;
var Visited: TList): TBalanceResult;
var
RunningBalance: Double;
Trans: TTransaction;
SubResult: TBalanceResult;
i: Integer;
begin
if Depth > FMaxDepth then
begin
Result.TotalBalance := 0;
Result.AvailableBalance := 0;
Result.FrozenTotal := 0;
Result.Recalculated := False;
Result.ErrorMessage := 'Maximum recursion depth exceeded. Possible circular dependency.';
Exit;
end;

// 从初始余额开始累加
RunningBalance := FAccount.InitialBalance;

// 遍历所有交易（按时间顺序，此处假设加载时已排序）
for Trans in FTransactions do
begin
// 只处理在开始时间之前的交易
if Trans.Timestamp > StartTime then
Continue;

// 跳过被冲正的交易（深度计算时需要忽略失效交易）
if IsReversed(Trans.ID) then
  Continue;

// 递归处理：如果交易关联了其他交易（例如分批结算），进入深度计算
if (Trans.RelatedTransactionID <> 0) and (not Visited.Contains(Trans.ID)) then
begin
  Visited.Add(Trans.ID);
  try
    // 找到关联的交易时间点，重新计算该点之前的余额作为参考（深度嵌套）
    // 此处简化：假设关联交易影响当前交易的生效条件，重新计算到关联交易时间
    SubResult := InternalCalculate(Trans.Timestamp, Depth + 1, Visited);
    if SubResult.ErrorMessage <> '' then
    begin
      Result := SubResult;
      Exit;
    end;
    // 根据子计算结果调整当前交易的金额或方向（示例：若子结果可用余额不足，则冻结当前交易）
    if SubResult.AvailableBalance < Trans.Amount then
    begin
      // 深度模型：标记为冻结或部分执行
      // 这里演示为将交易金额加入冻结池
      // 实际业务可扩展
    end;
  finally
    Visited.Remove(Trans.ID);
  end;
end;

// 正常累加余额
if Trans.Direction = tdIncome then
  RunningBalance := RunningBalance + Trans.Amount
else
  RunningBalance := RunningBalance - Trans.Amount;

end;

// 获取冻结金额
Result.FrozenTotal := GetEffectiveFrozenTotal(StartTime);
Result.TotalBalance := RunningBalance;
Result.AvailableBalance := RunningBalance - Result.FrozenTotal;
Result.Recalculated := (Depth > 0);
Result.ErrorMessage := '';
end;

function TDeepBalanceCalculator.CalculateBalance(AsOfTime: TDateTime): TBalanceResult;
var
Visited: TList;
begin
Reset;
Visited := TList.Create;
try
Result := InternalCalculate(AsOfTime, 0, Visited);
finally
Visited.Free;
end;
end;

end.

pascal
unit BalanceFacade;

interface

uses
System.SysUtils, System.Generics.Collections, Entity, BalanceCalculator;

type
/// 余额计算外观类
TBalanceFacade = class
private
FCalculator: TDeepBalanceCalculator;
FAccount: TAccount;
FTransactions: TObjectList;
public
constructor Create(AAccount: TAccount);
destructor Destroy; override;

/// <summary> 添加交易记录 </summary>
procedure AddTransaction(ATransaction: TTransaction);
/// <summary> 添加冻结记录 </summary>
procedure AddFrozen(ATransID: Integer; AAmount: Double; AExpire: TDateTime);
/// <summary> 获取指定时间的深度余额 </summary>
function GetBalance(AsOfTime: TDateTime): TBalanceResult;
/// <summary> 输出详细报告 </summary>
function GenerateReport(AsOfTime: TDateTime): string;

end;

implementation

constructor TBalanceFacade.Create(AAccount: TAccount);
begin
FAccount := AAccount;
FTransactions := TObjectList.Create(True);
FCalculator := TDeepBalanceCalculator.Create(FAccount);
end;

destructor TBalanceFacade.Destroy;
begin
FCalculator.Free;
FTransactions.Free;
inherited;
end;

procedure TBalanceFacade.AddTransaction(ATransaction: TTransaction);
begin
FTransactions.Add(ATransaction);
// 重新加载交易列表（实际应用中可能需要排序）
FCalculator.LoadTransactions(FTransactions);
end;

procedure TBalanceFacade.AddFrozen(ATransID: Integer; AAmount: Double; AExpire: TDateTime);
var
Frozen: TFrozenRecord;
begin
Frozen := TFrozenRecord.Create(ATransID, AAmount, AExpire);
FCalculator.AddFrozenRecord(Frozen);
end;

function TBalanceFacade.GetBalance(AsOfTime: TDateTime): TBalanceResult;
begin
Result := FCalculator.CalculateBalance(AsOfTime);
end;

function TBalanceFacade.GenerateReport(AsOfTime: TDateTime): string;
var
Res: TBalanceResult;
begin
Res := GetBalance(AsOfTime);
Result := Format('Account: %s (%d)' + sLineBreak +
'As Of: %s' + sLineBreak +
'Total Balance: %.2f' + sLineBreak +
'Frozen Amount: %.2f' + sLineBreak +
'Available Balance: %.2f' + sLineBreak +
'Recalculated: %s' + sLineBreak +
'Errors: %s',
[FAccount.Name, FAccount.ID, DateTimeToStr(AsOfTime),
Res.TotalBalance, Res.FrozenTotal, Res.AvailableBalance,
BoolToStr(Res.Recalculated, True), Res.ErrorMessage]);
end;

end.
2.4 演示程序（控制台测试）
pascal
program BalanceDemo;

{$APPTYPE CONSOLE}

uses
System.SysUtils,
System.Generics.Collections,
Entity,
BalanceCalculator,
BalanceFacade;

procedure RunDemo;
var
Account: TAccount;
Facade: TBalanceFacade;
Trans1, Trans2, Trans3: TTransaction;
BalanceResult: TBalanceResult;
NowTime: TDateTime;
begin
try
// 创建账户：ID 1001，名称“Demo Account”，币种CNY，初始余额1000
Account := TAccount.Create(1001, 'Demo Account', ctCNY, 1000);
Facade := TBalanceFacade.Create(Account);

NowTime := Now;

// 添加交易记录
Trans1 := TTransaction.Create(1, 1001, 500, ctCNY, tdIncome, NowTime - 5, 'Deposit');
Trans2 := TTransaction.Create(2, 1001, 200, ctCNY, tdExpense, NowTime - 3, 'Withdraw');
Trans3 := TTransaction.Create(3, 1001, 300, ctCNY, tdExpense, NowTime - 1, 'Payment');

Facade.AddTransaction(Trans1);
Facade.AddTransaction(Trans2);
Facade.AddTransaction(Trans3);

// 添加一笔冻结（例如交易2被冻结200元，持续到未来）
Facade.AddFrozen(2, 200, NowTime + 10);

// 计算当前余额
BalanceResult := Facade.GetBalance(NowTime);
Writeln(Facade.GenerateReport(NowTime));

// 演示深度递归（添加一个关联交易造成链式计算）
// 创建冲正交易，关联交易2，模拟深度依赖
Trans3.Free; // 释放原有trans3示例
Trans3 := TTransaction.Create(4, 1001, 250, ctCNY, tdExpense, NowTime - 2, 'Reversal for Trans2');
Trans3.RelatedTransactionID := 2;   // 关联交易2
Facade.AddTransaction(Trans3);

Writeln(sLineBreak + 'After adding reversal transaction (deep dependency):');
BalanceResult := Facade.GetBalance(NowTime);
Writeln(Facade.GenerateReport(NowTime));

Readln;

except
on E: Exception do
Writeln(E.ClassName, ': ', E.Message);
end;
end;

begin
RunDemo;
end.