java 调用ctp交易登录代码

以下是一个基本的 Java 代码示例，用于连接到 CTP 交易服务器并登录。这个示例使用 CTP API v6.3.15：

import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.*;

import org.bridj.Pointer;
import ctp.thostftdcuserapidatatype.*;
import ctp.thostftdcmdapi.*;

public class CtpTrader {
    private static final String FRONT_URL = "tcp://xxx.xxx.xxx.xxx:xxxx"; // CTP 服务器地址
    private static final String BROKER_ID = "xxxxxx"; // 经纪商代码
    private static final String INVESTOR_ID = "xxxxxx"; // 投资者代码
    private static final String PASSWORD = "xxxxxx"; // 用户密码

    private static AtomicInteger requestId = new AtomicInteger(0);
    private static Map<Integer, CtpRequest> requestMap = new ConcurrentHashMap<Integer, CtpRequest>();

    static {
        System.loadLibrary("thosttraderapi");
    }

    public static void main(String[] args) {
        System.out.println("CTP Trader Started");

        CThostFtdcTraderApi traderApi = CThostFtdcTraderApi.CreateFtdcTraderApi("./flow/");
        CtpTraderSpi traderSpi = new CtpTraderSpi(traderApi);
        traderApi.RegisterSpi(traderSpi);
        traderApi.RegisterFront(FRONT_URL);
        traderApi.SubscribePrivateTopic(THOST_TE_RESUME_TYPE.THOST_TERT_QUICK);
        traderApi.SubscribePublicTopic(THOST_TE_RESUME_TYPE.THOST_TERT_QUICK);
        traderApi.Init();

        System.out.println("CTP Trader Initialized");

        Scanner scanner = new Scanner(System.in);
        while (true) {
            String input = scanner.nextLine();
            if ("q".equals(input)) {
                break;
            } else if ("a".equals(input)) {
                CtpRequest request = new CtpRequest();
                request.setInstrument("rb2010"); // 合约代码
                request.setPrice(3600); // 价格
                request.setVolume(1); // 数量
                request.setOffsetFlag(THOST_FTDC_OF_Open); // 开仓
                request.setDirection(THOST_FTDC_D_Buy); // 买
                traderSpi.placeOrder(request);
            }
        }

        traderApi.Release();
        System.out.println("CTP Trader Stopped");
    }

    private static class CtpTraderSpi extends CThostFtdcTraderSpi {
        private final CThostFtdcTraderApi traderApi;

        public CtpTraderSpi(CThostFtdcTraderApi traderApi) {
            this.traderApi = traderApi;
        }

        @Override
        public void OnFrontConnected() {
            System.out.println("CTP Trader Connected");
            CThostFtdcReqUserLoginField loginField = new CThostFtdcReqUserLoginField();
            loginField.setBrokerID(BROKER_ID);
            loginField.setUserID(INVESTOR_ID);
            loginField.setPassword(PASSWORD);
            loginField.setMacAddress("00-00-00-00-00-00"); // MAC 地址
            loginField.setUserProductInfo("JavaTrader"); // 用户端产品信息
            loginField.setInterfaceProductInfo("JavaTrader"); // 接口端产品信息
            loginField.setProtocolInfo("td;0.1"); // 协议信息
            traderApi.ReqUserLogin(loginField, requestId.incrementAndGet());
        }

        @Override
        public void OnRspUserLogin(CThostFtdcRspUserLoginField rspUserLogin, CThostFtdcRspInfoField rspInfo, int requestId, boolean isLast) {
            if (rspInfo.getErrorID() == 0) {
                System.out.println("CTP Trader Logged In");
            } else {
                System.err.println(rspInfo.getErrorMsg());
            }
        }

        @Override
        public void OnRtnOrder(CThostFtdcOrderField order) {
            System.out.println("CTP Trader Order Returned: " + order.getInstrumentID() + " " + order.getDirection() + " " + order.getOffsetFlag() + " " + order.getLimitPrice() + " " + order.getVolumeTotalOriginal());
        }

        public void placeOrder(CtpRequest request) {
            CThostFtdcInputOrderField orderField = new CThostFtdcInputOrderField();
            orderField.setBrokerID(BROKER_ID);
            orderField.setInvestorID(INVESTOR_ID);
            orderField.setInstrumentID(request.getInstrument());
            orderField.setOrderPriceType(THOST_FTDC_OPT_LimitPrice);
            orderField.setLimitPrice(request.getPrice());
            orderField.setVolumeTotalOriginal(request.getVolume());
            orderField.setDirection(request.getDirection());
            orderField.setCombOffsetFlag(request.getOffsetFlag());
            orderField.setOrderRef(String.valueOf(requestId.incrementAndGet()));
            orderField.setUserID(INVESTOR_ID);
            orderField.setCombHedgeFlag(THOST_FTDC_HF_Speculation);
            traderApi.ReqOrderInsert(orderField, requestId.incrementAndGet());
            requestMap.put(requestId.get(), request);
        }
    }

    private static class CtpRequest {
        private String instrument;
        private double price;
        private int volume;
        private byte offsetFlag;
        private byte direction;

        public void setInstrument(String instrument) {
            this.instrument = instrument;
        }

        public String getInstrument() {
            return instrument;
        }

        public void setPrice(double price) {
            this.price = price;
        }

        public double getPrice() {
            return price;
        }

        public void setVolume(int volume) {
            this.volume = volume;
        }

        public int getVolume() {
            return volume;
        }

        public void setOffsetFlag(byte offsetFlag) {
            this.offsetFlag = offsetFlag;
        }

        public byte getOffsetFlag() {
            return offsetFlag;
        }

        public void setDirection(byte direction) {
            this.direction = direction;
        }

        public byte getDirection() {
            return direction;
        }
    }
}

在这个示例中，我们使用了 CTP API 的 `CThostFtdcTraderApi` 类来连接到交易服务器并发送交易指令。我们还使用了 `CtpTraderSpi` 类来处理 API 的回调函数，并发送交易请求。

在 `OnFrontConnected()` 回调函数中，我们使用 `CThostFtdcReqUserLoginField` 类来设置登录信息，并调用 `ReqUserLogin()` 方法来登录到交易服务器。在 `OnRspUserLogin()` 回调函数中，我们检查登录是否成功，并打印错误信息（如果有的话）。

在 `placeOrder()` 方法中，我们使用 `CThostFtdcInputOrderField` 类来设置交易指令信息，并调用 `ReqOrderInsert()` 方法来发送交易请求。我们还使用 `requestMap` 来保存每个请求的信息，以便在收到回调时使用。

最后，我们使用 `Scanner` 类来等待用户输入，并在输入 `q` 时退出程序。在输入 `a` 时，我们调用 `placeOrder()` 方法发送一笔交易请求。