D9 零基础速成笔记

一套完整的量化系统就五个环节：数据 → 回测 → 策略 → 模拟盘 → 实盘。你在 D1–D8 已经零零散散碰过其中几环，这一页把它们串成一条线。

 +------+    +----------+    +----------+    +---------------+    +------+
 | data | -> | backtest | -> | strategy | -> | paper trading | -> | live |
 +------+    +----------+    +----------+    +---------------+    +------+
    ^             ^                |                                  |
    |             +---- tune ------+                                  |
    +------------ new data, fills, live vs backtest gaps -------------+

data = 数据；backtest = 回测；strategy = 策略；paper trading = 模拟盘；live = 实盘；tune = 调整策略后再回测；最下面一行 = 实盘产生的新数据、成交记录、实盘和回测的差距，又流回第一环。这不是一条走一遍就结束的直线，而是一个转圈的循环。

 market data --> SIGNAL --> POSITION SIZE --> EXECUTION --> exchange
    (D3)         when?       how much?         how to place     |
                   ^                                            | fills (D4)
                   |                                            v
                   +----------------- RISK CONTROL <-----------+
                              stop loss / max position / kill switch

market data = 行情；SIGNAL = 信号；POSITION SIZE = 仓位管理；EXECUTION = 下单执行；exchange = 交易所；fills = 成交回报；RISK CONTROL = 风控（止损 / 最大持仓 / 一键停止）。风控是一个环：成交之后的结果回来，风控决定下一轮还能不能继续。

进组以后留意一件事：你们组是"公司自己拿钱跑策略"，还是"给用户提供策略工具"（网格、定投、跟单这类产品），还是两样都有。关心的重点不一样，各家分工也不同。

每种策略赚的钱，都来自市场上的某种"规律"。这种规律消失的时候，就是它亏钱的时候。

做市（同时挂买单和卖单，赚中间的差价）和套利（同一个东西在两个地方价格不一样，低买高卖）是交易所里最常见的两类，第 8、9 节专门一笔笔算。

这张表进组后很有用：听到任何一个策略，先问"它靠什么赚钱"和"什么行情会亏"。

回测的结论，最多和数据一样可靠。数据里少一根 K 线，回测就可能凭空多出、或者漏掉一笔成交。

下面是分页下载的骨架。Kline 就是一根 K 线，第 6 节的回测直接用它；KlineDownloader 负责分页拉取和检查缺口。解析 JSON 用的 Jackson 在 D10 加过依赖。接口地址和参数名以交易所文档为准，访问外部网站要遵守所在地和公司的规定。

import com.fasterxml.jackson.databind.ObjectMapper;
import java.math.BigDecimal;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.ArrayList;
import java.util.List;

/** 一根 K 线：开盘时间（UTC 毫秒）、开、高、低、收 */
record Kline(long openTime, BigDecimal open, BigDecimal high, BigDecimal low, BigDecimal close) {}

public class KlineDownloader {
    static final String BASE = "https://api.binance.com";    // 举例：公开接口，不用 Key；以文档为准
    static final long HOUR = 3_600_000L;                    // 1 小时 = 3,600,000 毫秒
    final HttpClient http = HttpClient.newHttpClient();
    final ObjectMapper json = new ObjectMapper();

    /** 从 start 拉到 end（都是 UTC 毫秒），每页最多 1000 根，按时间往后翻 */
    public List<Kline> download(String symbol, long start, long end) throws Exception {
        List<Kline> all = new ArrayList<>();
        long from = start;
        while (from < end) {
            String url = BASE + "/api/v3/klines?symbol=" + symbol + "&interval=1h"
                    + "&startTime=" + from + "&endTime=" + end + "&limit=1000";
            HttpResponse<String> resp = http.send(
                    HttpRequest.newBuilder(URI.create(url)).GET().build(),
                    HttpResponse.BodyHandlers.ofString());
            if (resp.statusCode() == 429) { Thread.sleep(60_000); continue; }  // 被限频：歇一分钟，重拉同一页
            if (resp.statusCode() != 200) throw new IllegalStateException("HTTP " + resp.statusCode());
            List<List<Object>> rows = json.readValue(resp.body(), List.class);
            if (rows.isEmpty()) break;                              // 这段时间没有数据了
            for (List<Object> r : rows) {                           // 每行：[开盘时间, "开", "高", "低", "收", ...]
                all.add(new Kline(((Number) r.get(0)).longValue(),
                        new BigDecimal((String) r.get(1)), new BigDecimal((String) r.get(2)),
                        new BigDecimal((String) r.get(3)), new BigDecimal((String) r.get(4))));
            }
            from = all.get(all.size() - 1).openTime() + HOUR;      // 下一页从最后一根的下一小时开始
            Thread.sleep(200);                                      // 主动慢一点，别碰限频
        }
        return all;
    }

    /** 逐根检查相邻两根的开盘时间差：正常应该正好差 step */
    public static List<String> checkGaps(List<Kline> ks, long step) {
        List<String> problems = new ArrayList<>();
        for (int i = 1; i < ks.size(); i++) {
            long d = ks.get(i).openTime() - ks.get(i - 1).openTime();
            if (d == 0)        problems.add("重复 " + ks.get(i).openTime());
            else if (d < 0)    problems.add("乱序 " + ks.get(i).openTime());
            else if (d > step) problems.add("缺 " + (d / step - 1) + " 根，在 " + ks.get(i - 1).openTime() + " 之后");
        }
        return problems;
    }
}

价格用字符串构造 BigDecimal，原因和 D2 一样：double 会带来误差。json.readValue(..., List.class) 会有一个"未检查的类型转换"编译警告，能正常运行；想干净可以用 Jackson 的 TypeReference。

双均线只有一条规则：短期平均价从下往上穿过长期平均价就买，从上往下穿过就卖。几行代码就能写完，但趋势策略的优点和毛病它全都有。

下面这张表用 3 日均线当快线、5 日均线当慢线。前 4 天慢线还算不出来（不满 5 天），不比较；第 5 天两条线都有了；从第 6 天起才能和前一天比，看有没有穿过去。

第 7 天：前一天快线 100.00 ≤ 慢线 100.00，今天 101.00 > 100.60，金叉。第 13 天：前一天 110.33 ≥ 109.20，今天 107.67 < 108.80，死叉。3 日均线 = 最近 3 天收盘相加 ÷ 3，比如第 11 天 = (109 + 112 + 111) ÷ 3 = 332 ÷ 3 ≈ 110.67。总页编程题 maCross 有一个测试就是这组数，天数从 0 数：金叉是 i = 6，死叉是 i = 12。

Java 写法：MovingAverage 用一个 ArrayDeque 维护滑动窗口；MaCrossSignal 每根 K 线收盘时调用一次，记住上一根的快线和慢线，只在穿过去的那一根返回买或卖。Side 就是 D4 的那个枚举。

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayDeque;

/** N 日均线：每来一个收盘价 O(1) 更新 */
class MovingAverage {
    private final int n;
    private final ArrayDeque<BigDecimal> window = new ArrayDeque<>();
    private BigDecimal sum = BigDecimal.ZERO;
    MovingAverage(int n) { this.n = n; }

    /** 加入今天的收盘价；窗口还没满 n 天时返回 null */
    BigDecimal add(BigDecimal close) {
        window.addLast(close);
        sum = sum.add(close);
        if (window.size() > n) sum = sum.subtract(window.removeFirst());   // 挤掉最老的那天
        return window.size() < n ? null : sum.divide(BigDecimal.valueOf(n), 8, RoundingMode.HALF_UP);
    }
}

/** 双均线信号：收盘后调用，返回 BUY / SELL / null；下单放到下一根 K 线 */
class MaCrossSignal {
    private final MovingAverage fast, slow;
    private BigDecimal lastFast, lastSlow;          // 上一根的快线、慢线
    MaCrossSignal(int fastDays, int slowDays) {
        fast = new MovingAverage(fastDays);
        slow = new MovingAverage(slowDays);
    }

    Side onClose(BigDecimal close) {
        BigDecimal f = fast.add(close), s = slow.add(close);
        Side signal = null;
        if (f != null && s != null && lastFast != null && lastSlow != null) {
            if (lastFast.compareTo(lastSlow) <= 0 && f.compareTo(s) > 0) signal = Side.BUY;    // 金叉
            if (lastFast.compareTo(lastSlow) >= 0 && f.compareTo(s) < 0) signal = Side.SELL;   // 死叉
        }
        lastFast = f;
        lastSlow = s;
        return signal;
    }
}

比较 BigDecimal 用 compareTo，不要用 equals：equals 会把 100.0 和 100.00 当成不相等。要求上一根的慢线也已经算出来，所以第一次能发信号的最早一根是第"慢线天数 + 1"根，和上表一致。

海龟法则的价值不在某个神奇指标，而在于它把"什么时候进、买多少、什么时候加、什么时候认赔、什么时候走"全写成了规则，没有一步需要"看感觉"。

满 4 个单位时打到 58,800：第 1 个单位（60,000 买）亏 1,200 × 0.041667 ≈ 50 U，第 2 个亏约 100 U，第 3 个约 150 U，第 4 个约 200 U，合计 500 U。此时一共持有 4 × 0.041667 = 0.166668 BTC，名义价值 ≈ 0.041667 × (60,000 + 61,200 + 62,400 + 63,600) = 0.041667 × 247,200 ≈ 10,300 U，大约 1 倍，不需要杠杆。总页编程题 turtlePlan 对 (10000, 60000, 2400) 应该返回：单位数量 0.041667、四个加仓价 60,000 / 61,200 / 62,400 / 63,600、每次加完后的止损 55,200 / 56,400 / 57,600 / 58,800、满仓打止损的总亏损 500。

回测就是拿过去的行情，假装策略当时就在跑，看它会赚还是亏。回测能帮你淘汰坏策略，但回测好看不等于策略好。

好消息：D4 写的零件一个都不用改。GridStrategy（网格策略）和 PaperMatcher（模拟撮合器）本来就只认"价格事件"，把真行情换成历史 K 线就是回测。Kline 直接用第 3 节定义的那个（一根 K 线：开盘时间、开、高、低、收），新写的只有 GridBacktest，也就是回测循环本身。pathInside 这个方法负责把一根 K 线拆成几个价格依次喂进去，为什么要拆、拆的顺序为什么是个问题，看代码下面的解释。

import java.math.BigDecimal;
import java.util.*;

// Kline 用第 3 节 KlineDownloader.java 里定义的 record，同一个包里直接能用

public class GridBacktest {
    static final BigDecimal FEE = new BigDecimal("0.0002");     // 挂单手续费 0.02%，只是举例

    /** 返回每根 K 线收盘时的账户总值，也就是资金曲线 */
    public static List<BigDecimal> run(List<Kline> klines, List<BigDecimal> levels, BigDecimal qty) {
        BigDecimal start = klines.get(0).open();
        GridState state = new GridState(levels, start);          // D4 的类，原样用
        GridStrategy strategy = new GridStrategy("BT", state);
        PaperMatcher matcher = new PaperMatcher();

        BigDecimal cash = new BigDecimal("10000"), btc = BigDecimal.ZERO;
        for (int i = 0; i < levels.size(); i++) {              // 和 D4 的 Main 一样挂初始单
            if (state.cells[i] == Cell.EMPTY) continue;
            Side side = state.cells[i] == Cell.BUY ? Side.BUY : Side.SELL;
            if (side == Side.SELL) {                              // 备货：卖单要的币按开盘价先买好
                BigDecimal amt = start.multiply(qty);
                cash = cash.subtract(amt).subtract(amt.multiply(FEE));
                btc = btc.add(qty);
            }
            matcher.place(new Order("BT-" + i + "-" + side.name().charAt(0) + "-0", side, levels.get(i), qty, i));
        }

        List<BigDecimal> equity = new ArrayList<>();
        for (Kline k : klines) {
            for (BigDecimal p : pathInside(k)) {                    // 一根 K 线拆成 4 个价格
                for (Fill f : matcher.onTrade(p)) {
                    BigDecimal amt = f.price().multiply(f.qty());
                    BigDecimal fee = amt.multiply(FEE);             // 每笔成交都扣手续费
                    if (f.side() == Side.BUY) { cash = cash.subtract(amt).subtract(fee); btc = btc.add(f.qty()); }
                    else                      { cash = cash.add(amt).subtract(fee);      btc = btc.subtract(f.qty()); }
                    strategy.nextOrderOnFill(f).ifPresent(matcher::place);   // 挂反向单
                }
            }
            equity.add(cash.add(btc.multiply(k.close())));          // 收盘时记一次账户总值
        }
        return equity;
    }

    /** 一根 K 线里价格先到最高还是先到最低，我们不知道，只能假设 */
    static List<BigDecimal> pathInside(Kline k) {
        boolean up = k.close().compareTo(k.open()) >= 0;
        return up ? List.of(k.open(), k.low(), k.high(), k.close())   // 收盘比开盘高：假设先探底再冲高
                  : List.of(k.open(), k.high(), k.low(), k.close());  // 收盘比开盘低：假设先冲高再探底
    }
}

和 D4 放在同一个包里（D4 的类型都是 public，直接能用）。输入的 K 线就是第 3 节下载、查过缺口的那一份。算出来的资金曲线，就是第 7 节算指标用的那一串数。

 position:  LONG 0.01 BTC @ 60000
 take-profit 60500        stop-loss 59500
 candle:    open 60000  high 60600  low 59400  close 60100

 path A: open -> high -> low -> close    hits 60500 first  => +5 U
 path B: open -> low -> high -> close    hits 59500 first  => -5 U

position = 仓位（做多 0.01 个，60,000 买入）；take-profit = 止盈价；stop-loss = 止损价；candle = 这根 K 线；path = 价格在 K 线里走的顺序。同一根 K 线，先碰最高价就是止盈赚 500 × 0.01 = 5 U，先碰最低价就是止损亏 5 U。只看 K 线，你分不出是哪一种。

小结：回测会骗人的三种情况是未来函数、过拟合、幸存者偏差，再加上 K 线里的先后顺序。遇到回测收益特别好看的时候，逐条排查一遍。

只看赚了多少不够。还要看：中间最难熬的时候亏了多少，以及每天的收益稳不稳。

套利不是"不会亏"，而是"不赌涨跌"。它赚的是一个很小、但看得见的差价，所以手续费、速度、意外情况决定了它最后赚不赚钱。

做市就是在订单簿上同时挂一张买单和一张卖单，谁来都跟他成交，赚的是买价和卖价中间那点差。做市的人让订单簿变厚，所以交易所欢迎他们。

风控先回答一个问题：最坏的时候，我最多亏多少？这个问题答不出来，策略就不能上线。

单子越大，你自己就把价格推得越远。拆成小单分批下，是拿时间换价格。

没有哪个策略是回测完直接上大钱的。每一步都要有明确的"过关数字"，达到了才进下一步。

本页的新词，以及前几天学过、这里又用到的词，都能在这里查到。

自测 10 题