振翅终能飞翔

支付系统账户体系可行性分析

2019-10-24T00:00:00+08:00

支付系统账户体系可行性分析

前言

百度百科中是这么定义支付的：支付又称付出、付给，多指付款，是发生在购买者和销售者之间的金融交换，是社会经济活动所引起的货币债权转移的过程。支付包括交易、清算和结算。

在我看来，一条支付指令中应包含交易方、对手方、以及订单信息(订单编码、交易金额、交收方式、货物详情)。如何有效维护交易双方的支付信息，是支付系统需要考虑的核心设计之一。

回顾

在现有资金清算系统中，主要由付款单和付款单流水两部分组成。其中，交易双方维护信息如下:

字段名	字段描述
payerSysUserId	交易方平台userId
payerSysUserAccount	交易方平台userAccount
payerSysUserName	交易方平台userName
payerBankAccName	交易方银行账户名
payerBankCardNum	交易方银行卡号
payerBankName	交易方银行名称
payerBankNo	交易方银行编码
payerExBankAccName	交易方虚拟账户名
payerExBankAccNo	交易方虚拟账户号

在平台付款单中，需要耦合交易双方的支付信息，以上支付信息，实际上是用户在不同渠道下开通的虚拟账户或平台内部账号信息。同上，在账单模块、以及业务订单模块，也都会维护多种账户耦合信息，这都是费心费力的事情。那么为何不在资金平台内维护用户的账户信息，在清算系统、结算系统、账单系统以及用户对账系统复用账户。

账户关联性

支付指令与支付账户的关联性

渠道支付指令

如上所示，账户是支付指令的基础，将账户信息维护在平台内部统一管理，可以保证交易订单有帐可查、有帐可对、有帐可控。

用户与支付账户的关联性

收银台账户管理

如上所示，支付方式中会展示出满足要求的所有账户列表，这些账户都维护在平台账户模块，可以在账户的控制属性(是否允许支付、是否允许代付、是否冻结)下进行权限分配等信息。

对账与支付账户的关联性

货款账户内部对账

随着货款线上化出入金的推进，账户对账是资金安全的一道重要保障。账户对账的是在账户交易流水上建立的双边对账，主要对账户的日终余额和日交易进行对账处理，这些都是建立在账户体系下实现的。

账单与支付账户的关联性

交易明细来源追踪

目前账单信息直接与平台用户信息、付款账号关联，关联数据较单一，且存在耦合字段较多，不利于业务和代码维护。让账单信息直接与账户关联，通过多表关联查询，可以有效解决这一问题。

小结

这是一个没有小结的小结。

中农网资金安全治理之对账体系建设

2019-10-08T00:00:00+08:00

中农网资金安全治理之对账体系建设

前言

随着中农网支付业务的飞速发展，每天产生的资金额已经达到上百万，清结算系统在保证线上服务稳定可靠的前提下，如何系统化的保障资金安全是非常核心且重要的课题，支付清结算系统经过不断地建设和打磨，在资金安全保障的多个方面均有一些总结和实践，保障资金安全是值得系统思考的课题，只言片语难以全面概括，需要更多的着墨才能较完整阐述，本文侧重点会阐述“对账”的概念，在支付&清结算领域，这是一个非常重要的专业名词，下文将介绍“对账”在分布式系统建设中的实践和解决方案，力求在系统覆盖度、资金准确性、时效等多个维度为系统资金安全保驾护航，实现更健壮可靠的资金履约。

背景&问题

随着中农网支付事业的蓬勃发展，支付清结算业务的复杂性也在不断的增高，总结起来，主要有以下几个特点：

场景多:包括鲜茧采购、线上虚拟户金额划转、线上诚意金划转、线上货款划转、ERP结算中心、OMS订单中心等多条业务线；对接多个业务系统。
链路长:清结算内部经历记账、汇总账单、付款、回执下载等多个流程。
交易金额大：目前日交易额已经达到百万级别，并不断增加中。
第三方支付通道不稳定：对接的第三方服务在并发场景下支付成功率无法保证到2个9。

在这样的业务背景下，我们的系统可谓险象环生。因业务高度复杂，稍有不慎就会出现问题，面对大量的日单量，同时还要确保结算金额的准确，这就让我们对问题的容忍度变得极低。这也给我们的资金安全保障造成了巨大的挑战。下面我们列举了一些系统日常运行过程中出现的问题。

场景1：加盟商(如鲜茧采购)核对账单，发现少了一笔费用。原因：结算单推动平台账单服务账单数据时，数据推送失败并丢失。	场景2：中农网资金平台线上订单状态变更支付成功，实际支付结果为未支付。原因：第三方支付渠道内线上支付结果与实际支付结果状态不一致。
场景3：结算已发起付款，但订单状态一直为支付中。原因：支付服务负载过高、支付排队队列阻塞等导致订单数据未能推送至银行。	场景4：拉取业务支付数据，出现订单重复支付问题。原因：接口问题、数据重算导致重复推送资金平台。

可以看出，这些都是一些上下游交互的边界场景下遇到的问题。当然不仅限于这些场景，凡是有系统交互、数据交互边界的场景，都会出现此类问题，我们称之为“一致性问题”。经粗略统计，我们清结算系统建立以来有70%左右的问题都属于一致性问题。

导致一致性问题的原因有很多，诸如：

幂等、并发控制不当。

基础环境故障：比如网络、数据库、消息中间将发生故障。

其他代码bug。

目前支付模块的日结算金额已达到百万级别，每个一致性问题都有可能给中农网造成巨大的损失。因此如何解决系统的一致性问题成为我们保障资金安全的重中之重。关于一致性问题，业内已经论述的非常成熟了，搜索引擎中搜索“一致性问题”，随处可见此概念的定义、问题阐述、意义以及解决思路，诸如：

强一致性协议: 两阶段提交、三阶段提交、TCC (Try-Confirm-Cancel)等

最终一致性: 主动轮询、异步确保、可靠消息、消息事务等

这些手段的目标都是在事中避免问题的发生。但是在实际场景中，无论是系统的内部逻辑还是外部环境都十分复杂多变、不可预知，我们很难完全避免问题。因此事后对于问题数据的发现以及修复就显得尤为重要。这些也正是我们这篇文章要论述的“对账”的核心使命。我们力求总结对账领域内最专业的思路和方法，并结合自身的业务特点，建设配送清结算的对账体系，构筑配送资金安全的坚固防线。在系统的整个构建过程中我们主要围绕以下几个目标：

场景覆盖的完整性：无死角覆盖清结算业务涉及的各个场景。
问题发现的准确性：能够准确的发现问题，保证不漏报，不误报。
问题处理的实时性：尽可能缩短问题处理的周期，极力避免可能造成的损失。

下面开始正式介绍中农网支付清结算对账体系的构建经验。

对账的定义

对账的概念随着金融、互联网行业的发展，定义上也经历了几个阶段的变化，如下：

stage 1 ：对账最初来源于会计核算，是为保证账簿记录正确可靠，对账簿中的相关数据进行检查和核对的工作。
stage 2 ：随着互联网金融或电商行业的发展，对账也扩大了应用范围，这一时期，对账是指在固定周期内，支付使用方和支付提供方（银行和第三方支付）相互确认交易、资金的正确性，保证双方的交易、资金一致正确。
stage 3 ：从广义来看，所有的跨端系统之间的数据核对都应该叫对账，主要是检查和发现数据在流转过程中的不一致问题。通常分为信息流的核对和资金流的核对。信息流核对主要是对业务数据之间的核对，资金流是对资金交易数据进行核对。

系统概况

清结算中心作为资金交付落地的中转中心,上游对接了类似鲜茧采购,ERP结算系统,OMS订单系统,虚拟户划转等外部系统,下游又对接了如茧丝-众邦支付,白糖-中信支付,茧丝-货款等多个支付渠道,不仅承上启下,而且同时对接处理多种信息流数据,系统的高度复杂性给对账的全面性和准确性造成了极大的困难,如图:

设计思路

从整体来看，按照时序维度的先后，系统对账主要分为三阶段的工作。分别是数据准备、数据核对和差错处理。在对账专业概念中，数据核对和差错处理又叫轧账和平账。三个环节紧密相连，从前期准备、问题发现、问题处理三个角度展开对账工作。

数据准备

在数据接入层，不同的第三方渠道会提供不同的数据接入方式。

数据拉取:我们主动拉取数据，如ftp拉取csv或接口方式下载账单文件。如众邦银行；
文件上传：我们主动将账单文件推送至第三方文件服务器，由第三方对账单数据进行解析。如中信银行；
数据推送:接入方将数据通过ETL(Extract-Transform-Load)推送到第三方数据仓库，由第三方对账单数据解析。

数据核对（轧账）

1.对账批次

一个批次代表一次对账操作，批次信息下会展示交易日单数、日交易额以及差错和缓冲数量。目前一个第三方渠道下一个批次；

2.对账缓存

对于平台支付成功但第三方渠道账单中不存在的流水记录，默认置于缓存池(最大缓存日期3天)。同时，缓存池中的数据也可被n+1日第三方渠道账单匹配。

3.对账方式

双边对账:以双方的数据互为基准对账。既要保证结算数据为成功的，支付平台也要成功，又要保证支付平台数据为成功的，结算数据也要成功。

4.对账粒度

明细对账：对双方的每条数据进行匹配，包括订单编号、交易金额、手续费金额等。清结算平台自定义出银行漏单、平台漏单、平台状态不符、平台短款、平台长款这几种差错类型。

5.银行账单列表

对每一个批次下第三方渠道的账单文件下载，解析为清结算统一识别适配的账单文件。方便在页面对数据进行比对、排错。

6.对账时机

不同的第三方渠道下对账策略不一样，需要根据定时任务手动适配不同渠道下对账时机。如众邦银行适配为n+1日12：00开始对账操作。

差错处理（平帐）

差错处理主要是对数据核对过程中发现的问题数据进行处理。我们会建立一个统一结构的差错记录，将数据核对发现的问题进行统一存储。差错记录中的数据会进行二次核对，避免由于日切等原因造成的问题错报。对于那些真实存在问题的数据我们会提供两种解决模式，如果是常见的问题，且有一套标准的解决方案的话，我们会把它系统化，采取系统自动修复的方式；如果系统无法自动修复，那么我们会进行系统报警，并进行人工处理。

小结

这是一个没有小结的小结。-_-

等待通知机制之wait()/notify()

2019-09-16T00:00:00+08:00

等待通知机制之wait()/notify()

1.wait()/notify官方定义

wait()/notify是Object类中方法，且定义为final级别(不可修改).

jdk8中对wait()的注释为

/ ** *使当前线程等待，直到另一个线程为此对象调用* {@link java.lang.Object＃notify（）}方法或* {@link java.lang.Object＃notifyAll（）}方法。 *换句话说，此方法的行为就像它只是*执行调用{@code wait（0）}一样。 * <p> *当前线程必须拥有此对象的监视器。线程*释放此监视器的所有权并等待，直到另一个线程*通过调用{@code notify}方法或* {@code notifyAll}方法通知等待此对象监视器的线程唤醒*。然后线程等待，直到它可以*重新获得监视器的所有权并继续执行。 * <p> *与在一个参数版本中一样，中断和虚假唤醒是*可能的，并且此方法应始终在循环中使用：* <pre> * synchronized（obj）{* while（<condition not hold> ）* obj.wait（）; * ... //执行适合条件的操作*} * </ pre> *此方法只能由作为此对象监视器的所有者*的线程调用。有关线程可以成为监视器所有者的方式的*描述，请参阅{@code notify}方法。 * * @throws IllegalMonitorStateException如果当前线程不是对象监视器的所有者。 * @throws InterruptedException如果任何线程在当前线程*等待通知之前或当前线程中断*当前线程。当抛出此异常时，将清除当前线程的<i>中断*状态</ i>。 * @see java.lang.Object＃notify（）* @see java.lang.Object＃notifyAll（）* /

jdk8中对notify()的注释为

/ ** *唤醒正在等待此对象的*监视器的单个线程。如果任何线程正在等待此对象，则选择其中一个*被唤醒。选择是任意的，由*实施自行决定。线程通过调用{@code wait}方法之一等待对象的*监视器。 * <p> *唤醒的线程将无法继续，直到当前*线程放弃对此对象的锁定。唤醒的线程将以通常的方式与可能*主动竞争同步此对象的任何其他线程竞争;例如，*唤醒线程在*下一个锁定此对象的线程中没有可靠的特权或劣势。 * <p> *此方法只能由作为此对象监视器的所有者*的线程调用。线程以三种方式之一成为*对象监视器的所有者：* <ul> * <li>通过执行该对象的同步实例方法。 * <li>通过执行在对象上同步的{@code synchronized}语句*的主体。 * <li>对于{@code Class，}类型的对象，通过执行该类的* synchronized静态方法。 * </ ul> * <p> *一次只能有一个线程拥有对象的监视器。 * * @throws IllegalMonitorStateException如果当前线程不是此对象监视器的所有者。 * @see java.lang.Object＃notifyAll（）* @see java.lang.Object #wait（）* /

jdk8中对notifyAll()的注释为

/ ** *唤醒等待此对象监视器的所有线程。 A *线程通过调用* {@code wait}方法之一等待对象的监视器。 * <p> *唤醒的线程将无法继续，直到当前*线程放弃此对象上的锁定。唤醒的线程*将以通常的方式与可能*主动竞争同步此对象的任何其他线程竞争;例如，*被唤醒的线程在下一个锁定此对象的线程中没有可靠的特权或劣势。 * <p> *此方法只能由作为此对象监视器的所有者*的线程调用。有关线程可以成为监视器所有者的方式的*描述，请参阅{@code notify}方法。 * * @throws IllegalMonitorStateException如果当前线程不是此对象监视器的所有者。 * @see java.lang.Object＃notify（）* @see java.lang.Object #wait（）* /

2.wait()和sleep()的区别

-wait是object类的方法，sleep是Thread的方法。

-wait方法必须在同步上下文中使用(如synchronized)，会使当前线程释放对象的内置锁并等待，使得当前线程阻塞，直到其他线程唤醒当前线程。sleep方法会使当前线程休眠，是基于Thread的方法，并不会释放调用对象的锁，直到休眠结束重新获得对象锁。

3.notify()/notifyAll()的作用

notify是通知一个线程获取对象内置锁，notifyAll是唤醒等待此对象内置锁的所有线程，如果当前线程不是此对象内置锁的所有者，会抛出IllegalMonitorStateException。

被唤醒的线程无法立即执行，必须等待唤醒线程释放对象内置锁。

4.等待通知之交叉打印奇偶数

public class TwoThreadWaitNotify extends Object {

    private int start = 1;

    private boolean flag = false;

    public static void main(String[] args) throws Exception {
        TwoThreadWaitNotify number = new TwoThreadWaitNotify();
        Thread t1 = new Thread(new OuNum(number));
        t1.setName("偶数");
        Thread t2 = new Thread(new JiNum(number));
        t2.setName("奇数");

        t1.start();
        t2.start();
    }

    public static class OuNum implements Runnable {
        private TwoThreadWaitNotify number;

        public OuNum(TwoThreadWaitNotify number) {
            this.number = number;
        }

        public void run() {
            while (number.start < 100) {
                synchronized (TwoThreadWaitNotify.class) {
                    System.out.println("偶数线程抢到锁了");
                    if (number.flag) {
                        System.out.println(Thread.currentThread().getName() + "+-+偶数" + number.start);
                        number.start++;

                        number.flag = false;
                        TwoThreadWaitNotify.class.notify();
                    } else {
                        try {
                            System.out.println("偶数线程开始阻塞");
                            TwoThreadWaitNotify.class.wait();
                            System.out.println("偶数线程阻塞结束");
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }

    public static class JiNum implements Runnable {
        private TwoThreadWaitNotify number;

        public JiNum(TwoThreadWaitNotify number) {
            this.number = number;
        }

        public void run() {
            while (number.start < 100) {
                synchronized (TwoThreadWaitNotify.class) {
                    System.out.println("奇数线程抢到锁了");
                    if (!number.flag) {
                        System.out.println(Thread.currentThread().getName() + "+-+奇数" + number.start);
                        number.start++;

                        number.flag = true;
                        TwoThreadWaitNotify.class.notify();
                    } else {
                        try {
                            System.out.println("奇数线程开始阻塞");
                            TwoThreadWaitNotify.class.wait();
                            System.out.println("奇数线程阻塞结束");
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }

}

输出结果如下:

偶数线程抢到锁了
偶数线程开始阻塞
奇数线程抢到锁了
奇数+-+奇数1
奇数线程抢到锁了
奇数线程开始阻塞
偶数线程阻塞结束
偶数线程抢到锁了
偶数+-+偶数2
偶数线程抢到锁了
偶数线程开始阻塞
奇数线程阻塞结束
奇数线程抢到锁了
奇数+-+奇数3
奇数线程抢到锁了
奇数线程开始阻塞
偶数线程阻塞结束
偶数线程抢到锁了
偶数+-+偶数4
偶数线程抢到锁了
偶数线程开始阻塞
奇数线程阻塞结束
奇数线程抢到锁了
奇数+-+奇数5

5.小结

notify以及wait方法作为基类object原生方法，和jvm中对象管理机制有一定关系。实例对象内部会含有一个内置锁(在jdk注释处可能描述为monitor)，jvm控制内置锁与线程之前的绑定关系，控制线程的执行与等待。所以，要想深入了解其中的运行原理，还需对jvm有一定的了解与深入。

设计模式-代理模式

2019-03-18T00:00:00+08:00

代理(Proxy)是一种设计模式,提供了对目标对象另外的访问方式;即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能. 这里使用到编程中的一个思想:不要随意去修改别人已经写好的代码或者方法,如果需改修改,可以通过代理的方式来扩展该方法。

应用场景：为其他对象提供一种代理以控制对这个对象的访问。从结构上来看和 Decorator 模式类似，但 Proxy 是控制，更像是一种对功能的限制，而 Decorator 是覆盖或者增加职责。 Spring 的 Proxy 模式在 AOP 中有体现，比如 JdkDynamicAopProxy 和 Cglib2AopProxy。

归类	特点	穷举
结构型模式	执行者、代理人对于被代理人来说，这件事一定要做的。但是我自己又不想做或者没时间做对于代理人而言，需要获取到被代理人的资料，只是参与整个过程的某个或几个环节	租房中介、售票黄牛、婚介、事务代理、非侵入式日志监听

使用代理模式主要有两个目的:一是保护目标对象，二是增强目标对象。

静态代理

举个例子：人到了适婚年龄，父母总是迫不及待希望早点抱孙子。而现在社会的人在各种压力之下，都选择晚婚晚育。于是着急的父母就开始到处为自己的子女相亲，比子女自己还着急。这个相亲的过程，就是一种我们人人都有份的代理。来看代码实现：

顶层接口 Person：

public interface Person {
    /**
     * 相亲
     */
    void findLove();
}

儿子要找对象,实现Son类:

public class Son implements Person {
    @Override
    public void findLove() {
        System.out.println("儿子要求:肤白貌美大长腿");
    }
}

父亲要帮儿子相亲,实现Father(可怜天下老父亲-_-)

public class Father implements Person {
    private Son son;

    public Father(Son son) {
        this.son = son;
    }

    @Override
    public void findLove() {
        System.out.println("父母物色对象");
        son.findLove();
        System.out.println("双方同意交往,确立交往");
    }
}

来看测试代码:

    public static void main(String[] args) {
        Father father = new Father(new Son());
        father.findLove();
    }

运行结果:

父母物色对象
儿子要求:肤白貌美大长腿
双方同意交往,确立交往

在上述场景中,父亲作为执行者，儿子作为被代理者，对外是父亲(执行者)帮儿子(代理对象)相亲，保护了儿子(代理对象)不对外暴露，同时也对儿子(代理对象)的相亲行为做了前置增强和后置增强(功能增强)。

对于分布式业务场景中,我们通常会对数据库进行分库分表，在对数据进行操作之前便可以进行前置设置数据源。

动态代理

JDK动态代理

动态代理和静态对比基本思路是一致的，只不过动态代理功能更加强大，随着业务的扩展适应性更强。如果还以找对象为例，使用动态代理相当于是能够适应复杂的业务场景。不仅仅只是父亲给儿子找对象，如果找对象这项业务发展成了一个产业，进而出现了媒婆、婚介所等这样的形式。那么，此时用静态代理成本就更大了，需要一个更加通用的解决方案，要满足任何单身人士找对象的需求。我们升级一下代码，先来看 JDK 实现方式：

创建媒婆(婚介)JDKMeipo类:

public class JDKMeipo implements InvocationHandler {
    private Person target;

    public Object getInstance(Person target) {
        this.target = target;
        Class<? extends Person> clazz = target.getClass();
        return Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        Object invoke = method.invoke(this.target, args);
        after();
        return invoke;
    }

    private void before() {
        System.out.println("我是媒婆,我已经拿到你的需求了...");
        System.out.println("开始物色...");
    }

    private void after() {
        System.out.println("如果合适的话,就准备办事...");
    }
}

创建客户Customer类:

public class Customer implements Person {
    @Override
    public void findLove() {
        System.out.println("我是客户,我的要求是白富美...");
    }
}

测试类:

public class DynamicProxyTest {
    public static void main(String[] args) {
        Person person = (Person) new JDKMeipo().getInstance(new Customer());
        person.findLove();
    }
}

测试输出:

我是媒婆,我已经拿到你的需求了...
开始物色...
我是客户,我的要求是白富美...
如果合适的话,就准备办事...

用户只要是进行相亲行为,都可以在媒婆(JDKMeipo)处创建代理对象,执行者便可以对代理对象的行为进行增强操作。

JDK Proxy 采用字节重组，重新生成的对象来替换原始的对象以达到动态代理的效果。JDK Proxy生成对象的步骤如下:

拿到被代理对象的引用，并且通过反射的方式获取到它所实现的所有接口。
JDK Proxy 重新生成一个新类，同时新类要实现被代理类所实现的所有接口。
动态生成 Java 代码，把新加的业务逻辑方法由一定的逻辑代码去维护。
编译新生成的 Java 代码.class。
再重新加载到 JVM 中运行。

以上这个过程就叫字节码重组。JDK 中有一个规范，在 ClassPath 下只要是以 $ 开头的 class 文件一般是自动生成的。

记第一篇博客

2019-03-15T00:00:00+08:00

记录我的第一篇博客

心血来潮，想着搭建个人技术博客。坚持下去，做技术的分享人，做自我的管理者。

路漫漫兮其修远矣，吾将上下而求索。。。