美股市场是全球最大、流动性最强的金融市场之一，涵盖了科技、金融、医疗等多个行业的优质公司。对于量化交易者来说，美股行情数据是构建策略的基础。无论是高频交易、均值回归策略，还是基于机器学习的预测模型，都离不开准确、及时的行情数据。

然而，获取高质量的美股数据并不容易。许多数据源要么价格昂贵，要么接口复杂，难以满足量化交易的需求。因此，找到一个性价比高且易于使用的接口显得尤为重要。

接口的基本调用功能

最近使用的这款实时行情接口提供了丰富的功能，包括实时行情、历史K线、深度数据等。以下是一些基本调用功能的示例代码：

1. 获取实时行情

package org.example.ws;

import com.alibaba.fastjson2.JSONObject;
import jakarta.websocket.*;

import java.io.IOException;
import java.net.URI;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class WebsocketExample {

    private static Session session;

    private static final String WS_URL = "wss://data.infoway.io/ws?business=crypto&apikey=yourApikey";

    public static void main(String[] args) throws Exception {
        try {
            // create WebSocket connect
            WebSocketContainer container = ContainerProvider.getWebSocketContainer();
            session = container.connectToServer(WebsocketExample.MyClientEndpoint.class, URI.create(WS_URL));
            // send message

            JSONObject jsonObject = new JSONObject();
            jsonObject.put("code", 10000);
            jsonObject.put("trace", "01213e9d-90a0-426e-a380-ebed633cba7a");
            JSONObject data = new JSONObject();
            data.put("codes", "BTCUSDT");
            jsonObject.put("data", data);

            session.getBasicRemote().sendText(jsonObject.toJSONString());

            ScheduledExecutorService pingExecutor = Executors.newScheduledThreadPool(1);
            Runnable pingTask = WebsocketExample::ping;
            pingExecutor.scheduleAtFixedRate(pingTask, 30, 30, TimeUnit.SECONDS);

            // keep running
            Thread.sleep(600 * 1000);
            // close connect
            session.close();
        } catch (DeploymentException | IOException | InterruptedException e) {
            e.printStackTrace();
        }
    }

    @ClientEndpoint
    public static class MyClientEndpoint {
        @OnOpen
        public void onOpen(Session session) {
            System.out.println("Connection opened: " + session.getId());
        }

        @OnMessage
        public void onMessage(String message, Session session) {
            try {
                System.out.println("Message received: " + message);
            } catch (Exception e) {
            }
        }

        @OnClose
        public void onClose(Session session, CloseReason reason) {
            System.out.println("Connection closed: " + session.getId() + ", reason: " + reason);
        }

        @OnError
        public void onError(Throwable error) {
            error.printStackTrace();
        }
    }

    //ping message
    public static void ping() {
        try {
            JSONObject jsonObject = new JSONObject();
            jsonObject.put("code", 10010);
            jsonObject.put("trace", "01213e9d-90a0-426e-a380-ebed633cba7a");
            session.getBasicRemote().sendText(jsonObject.toJSONString());
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

高阶策略开发：基于波动率的动态仓位管理

基于获取的实时和历史数据，我们可以开发更复杂的量化策略。以下是一个基于波动率的动态仓位管理策略示例：

策略逻辑

计算波动率：使用历史数据计算股票的滚动波动率。

动态调整仓位：波动率较高时减少仓位，波动率较低时增加仓位。

生成交易信号：根据波动率和价格趋势生成买入或卖出信号。

代码实现

import numpy as np
 
# 计算滚动波动率
def calculate_volatility(data, window=20):
    data['returns'] = data['close'].pct_change()
    data['volatility'] = data['returns'].rolling(window=window).std() * np.sqrt(252)  # 年化波动率
    return data
 
# 动态仓位管理策略
def dynamic_position_management(data, volatility_threshold_high=0.3, volatility_threshold_low=0.1):
    data['position'] = 1.0  # 默认满仓
    data.loc[data['volatility'] > volatility_threshold_high, 'position'] = 0.5  # 高波动率时减仓
    data.loc[data['volatility'] < volatility_threshold_low, 'position'] = 1.5  # 低波动率时加仓
    
    # 生成交易信号
    data['signal'] = np.where(data['position'].shift(1) > data['position'], -1, 1)
    return data
 
# 获取AAPL的历史数据
aapl_data = get_historical_data("AAPL.US", query_kline_num=252)
aapl_data = calculate_volatility(aapl_data)
aapl_data = dynamic_position_management(aapl_data)
 
# 计算策略收益
aapl_data['strategy_return'] = aapl_data['position'].shift(1) * aapl_data['returns']
cumulative_return = (1 + aapl_data['strategy_return']).cumprod()
 
# 绘制策略净值曲线
import matplotlib.pyplot as plt
 
plt.figure(figsize=(10, 6))
plt.plot(cumulative_return)
plt.title('Dynamic Position Management Strategy - AAPL')
plt.xlabel('Date')
plt.ylabel('Cumulative Return')
plt.show()[]()