双重入口：是什么，何时使用以及如何做

珍惜时间，勤奋学习！今天给大家带来《双重入口：是什么，何时使用以及如何做》，正文内容主要涉及到等等，如果你正在学习Golang，或者是对Golang有疑问，欢迎大家关注我！后面我会持续更新相关内容的，希望都能帮到正在学习的大家！

那些开始在金融部门工作的人可能会遇到这个术语“双重进入”，这是管理交易和财务记录的基本概念。在这篇文章中，我想详细说明该概念的使用方式，以及其对维持财务交易的完整性的重要性

>解释一个示例的双重输入是什么。因此，请考虑您将$ 1,000的pix转让以支付帐户；此转移过程实际上执行了两个操作：

第一个操作是您帐户中$ 1,000的借方；
• 第二个操作是$ 1,000的目标帐户
• >至关重要的是，要成功进行交易，这两个操作都可以正确记录。如果其中一个操作失败，则需要逆转整个过程以维持帐户的完整性。这个概念被称为双重进入，对于确保财务交易的完整性至关重要

金融部门的重要性

>双重入口系统在金融领域至关重要，原因有多种：

会计准确性：

确保所有财务交易都是准确记录的，从而减少了帐户中的错误和差异

促进审计：
• 您可以轻松跟踪交易的历史并确定可能的不规则或欺诈 法规合规性：
符合金融部门的法律和监管要求，这些要求需要精确和透明的记录
• 银行对帐：简化了对帐过程，允许内部记录和银行语句之间的有效比较
• 金融系统以外的应用程序 传统上与财务系统相关联的双重入口系统也可以应用于其他环境中，就像库存管理和物流中必须记录产品进入和退出
在所有这些情况下，每次交易都会影响两个不同的记录，有助于保持数据完整性和可追溯性
• 如何发展 让我们在此示例中创建一个简单的示例。

package main

import (
    "fmt"
    "time"
)

type account struct {
    id      string
    balance float64
}

type transaction struct {
    id        string
    fromid    string
    toid      string
    amount    float64
    timestamp time.time
}

func (a *account) debit(amount float64) error {
    if a.balance < amount {
        return fmt.errorf("saldo insuficiente")
    }
    a.balance -= amount
    return nil
}

func (a *account) credit(amount float64) {
    a.balance += amount
}

func transfer(from, to *account, amount float64) error {
    // primeira entrada: débito da conta origem
    if err := from.debit(amount); err != nil {
        return err
    }

    // segunda entrada: crédito na conta destino
    to.credit(amount)

    return nil
}

func main() {
    // criando contas de exemplo
    accounta := &account{
        id:      "conta_a",
        balance: 1000.0,
    }

    accountb := &account{
        id:      "conta_b",
        balance: 500.0,
    }

    fmt.printf("antes da transferência:\nconta a: r$%.2f\nconta b: r$%.2f\n\n", 
        accounta.balance, accountb.balance)

    // realizando uma transferência
    err := transfer(accounta, accountb, 300.0)
    if err != nil {
        fmt.printf("erro na transferência: %v\n", err)
        return
    }

    fmt.printf("após a transferência:\nconta a: r$%.2f\nconta b: r$%.2f\n", 
        accounta.balance, accountb.balance)
}

在此示例中，我们实现：

>

>一个帐户结构，代表具有id和余额

的帐户

交易结构以记录交易的详细信息

借方和信用方法在帐户上执行操作

>实现双​​重输入概念的传输函数，以确保执行两个操作
>

执行后，此代码演示了从帐户a到帐户b的300.00 $ $转移，显示了操作前后的余额。如果在过程中存在任何错误（例如余额不足），则交易未完成

so被称为操作

• 在我们之前看到的示例中，我们创建了两个构成交易的基本操作：>
• >删除源帐户价值的债务运营
>一个将金额添加到目标帐户
• 的信用操作（信用）
• 这些操作是金融交易的基本单位，应始终成对进行以维护双重遵守原则。每个操作都是原子，也就是说，它是完全发生的，要么没有发生，因此没有中间状态 在代码中，我们将这些操作作为帐户结构的单独方法实施，但是它们始终通过传输功能召集，以确保尊重双重输入原则
封装和安全

为了确保只能通过交易功能更改余额，我们可以使用封装并使帐户结构中的余额字段私有。查看我们如何修改以前的代码：

type account struct {
    id      string
    balance float64  // note o 'b' minúsculo tornando o campo privado
}

// método getter para acessar o saldo
func (a *account) getbalance() float64 {
    return a.balance
}

// métodos de débito e crédito agora trabalham com o campo privado
func (a *account) debit(amount float64) error {
    if a.balance < amount {
        return fmt.errorf("saldo insuficiente")
    }
    a.balance -= amount
    return nil
}

func (a *account) credit(amount float64) {
    a.balance += amount
}

使用此实现，只能通过软件包本身的方法来修改余额字段，以确保所有余额变化都通过了双输入系统

当然，实现双重输入系统还有其他重要考虑因素，例如使用交易数据库确保原子交易并从所有审核目的实现详细日志。这些实践有助于保持系统的完整性和可追溯性

生产代码

作为实现双重入口系统的工具的一个实际示例，我们有伊萨兹（midaz），这是莱利安（lerian）维护的分类帐开源，他使用此技术来确保金融交易的完整性。 与基本上所有封闭的巴西金融系统不同，

使我们能够检查并公开讨论双重进入的使用并研究这种实践在生产环境中的工作方式。
• 如何创建操作
• >让我们检查一下midaz如何在交易中创建单个操作。在创建交易中，调用了接收交易详细信息和所涉及帐户的创建方法。遵循创建操作的代码，评论：

func (uc *UseCase) CreateOperation(ctx context.Context, 
        accounts []*account.Account, 
        transactionID string, 
        dsl *goldModel.Transaction, 
        validate goldModel.Responses, 
        result chan []*operation.Operation, 
        err chan error) {

    // Declara uma lista para armazenar as operações criadas
    var operations []*operation.Operation

    // Cria uma lista `fromTo` contendo as contas de origem e destino envolvidas na transação
    var fromTo []goldModel.FromTo
    fromTo = append(fromTo, dsl.Send.Source.From...)      // Adiciona contas de origem
    fromTo = append(fromTo, dsl.Send.Distribute.To...)    // Adiciona contas de destino

    // Percorre todas as contas envolvidas na transação
    for _, acc := range accounts {
        // Verifica se a conta está na lista `fromTo`
        for i := range fromTo {

            // Verifica se a conta atual está envolvida na transação, seja pelo ID ou pelo alias.
            if fromTo[i].Account == acc.Id || fromTo[i].Account == acc.Alias {

                // Define o saldo atual da conta
                balance := operation.Balance{
                    Available: &acc.Balance.Available,
                    OnHold:    &acc.Balance.OnHold,
                    Scale:     &acc.Balance.Scale,
                }

                // Valida a operação e calcula os valores da transação
                amt, bat, er := goldModel.ValidateFromToOperation(fromTo[i], validate, acc)
                if er != nil {
                    logger.Errorf("Error creating operation: %v", er)
                }

                // Converte os valores da transação para float64 e a escala de casas decimais
                v := float64(amt.Value)
                s := float64(amt.Scale)

                amount := operation.Amount{
                    Amount: &v,
                    Scale:  &s,
                }

                // Define o saldo da conta após a operação
                ba := float64(bat.Available)
                boh := float64(bat.OnHold)
                bs := float64(bat.Scale)

                balanceAfter := operation.Balance{
                    Available: &ba,
                    OnHold:    &boh,
                    Scale:     &bs,
                }

                // Determina se a operação será um débito ou crédito
                var typeOperation string
                if fromTo[i].IsFrom {
                    typeOperation = constant.DEBIT
                } else {
                    typeOperation = constant.CREDIT
                }

                // Cria uma nova operação com os dados processados
                save := &operation.Operation{
                    ID:              pkg.GenerateUUIDv7().String(),
                    TransactionID:   transactionID,
                    Type:            typeOperation,
                    AssetCode:       dsl.Send.Asset,
                    Amount:          amount,
                    Balance:         balance,
                    BalanceAfter:    balanceAfter,
                    AccountID:       acc.Id,
                    AccountAlias:    acc.Alias,
                    ...
                }

                // Salva a operação no banco de dados
                op, er := uc.OperationRepo.Create(ctx, save)
                if er != nil {
                    logger.Errorf("Error creating operation: %v", er)
                }

                // Adiciona a operação criada à lista de operações
                operations = append(operations, op)

                break // Sai do loop para evitar múltiplas inclusões da mesma conta
            }
        }
    }

    // Envia a lista de operações criadas pelo canal `result`
    result <- operations
}

>使阅读，删除记录仪和痕迹以及其他一些细节变得更容易，但是您可以在创建事务和操作的github中全面分析代码。在评论中，如果您想解开一篇文章，并解释了如何完全完成财务交易的代码

本篇关于《双重入口：是什么，何时使用以及如何做》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于Golang的相关知识，请关注golang学习网公众号！