FIX三天日记-quick fix简介

举报
兔老大 发表于 2022/08/12 22:32:27 2022/08/12
【摘要】 一、介绍 fix协议在上篇已经学习了，不再介绍。 QuickFIX是一款C++实现的开源FIX引擎，同时提供Python等多种语言实现，具体看quickfix git地址 官网已经介绍如何编译quickfix、配置文件字段含义等等，我假设你可以看懂，用的时候查阅即可，我就不复制过来了，本文是教你快速认识此框架并且用起来。 二...

一、介绍

fix协议在上篇已经学习了，不再介绍。

QuickFIX是一款C++实现的开源FIX引擎，同时提供Python等多种语言实现，具体看quickfix git地址

官网已经介绍如何编译quickfix、配置文件字段含义等等，我假设你可以看懂，用的时候查阅即可，我就不复制过来了，本文是教你快速认识此框架并且用起来。

二、主要类介绍

想了解如何用某个组件，先了解他的成员都有哪些。

2.1 Application

若是须要使用QuickFIX开发FIX应用，则须要实现FIX::Application接口，并重载不一样FIX协议版本的MessageCracker::OnMessage接口，如FIX42::MessageCracker。

class Application
{
public:
  virtual ~Application() {};
  /// Notification of a session begin created
  virtual void onCreate( const SessionID& ) = 0;
 
  /// Notification of a session successfully logging on
  virtual void onLogon( const SessionID& ) = 0;
 
  /// Notification of a session logging off or disconnecting
  virtual void onLogout( const SessionID& ) = 0;
 
  /// Notification of admin message being sent to target
  virtual void toAdmin( Message&, const SessionID& ) = 0;
 
  /// Notification of app message being sent to target
  virtual void toApp( Message&, const SessionID& )
  EXCEPT ( DoNotSend ) = 0;
 
  /// Notification of admin message being received from target
  virtual void fromAdmin( const Message&, const SessionID& )
  EXCEPT ( FieldNotFound, IncorrectDataFormat, IncorrectTagValue, RejectLogon ) = 0;
 
  /// Notification of app message being received from target
  virtual void fromApp( const Message&, const SessionID& )
  EXCEPT ( FieldNotFound, IncorrectDataFormat, IncorrectTagValue, UnsupportedMessageType ) = 0;
};

 onCreate：当Fix Session创建时调用。
onLogon：当Fix Session登陆成功时调用。
onLogout：当Fix Session退出时调用。
fromAdmin：当收到一个Admin类型消息时调用。
fromApp：当收到一个不属于Admin 类型消息时调用。
toAdmin：当发送一个admin类型消息调用。
toApp：当发送一个非admin(业务类型)消息调用。

admin一般是服务提供方，app是客户端

对于支持交易业务的FIX Initiator应用，通常重写4个基本消息，OnMessage(NewOrderSingle）、OnMessage(CancelRequest)、 OnMessage(ExecutionReport)、 OnMessage(CancelReject)，用于做委托、撤单、执行回包和对撤单拒绝等4项业务。

更全面的介绍是这样的，入门选手可以先不了解这么详细：

  • onCreate：当quickfix创建新会话时调用。会话一旦创建，将应用程序的整个生命周期内保持存在。不管对方是否连接到会话，会话都存在。一旦创建了会话，就可以开始向它发送消息。如果没有人登录，则消息将在与对方建立连接时发送。
  • onLogon：当建立连接并完成FIX登录过程(双方交换有效的登录消息)时调用该函数。
  • onLogout：当某个 FIX 会话不再在线时进行通知，这可能发生在正常的注销交换过程中，或者由于强制终止或网络连接丢失。
  • toAdmin：使您可以了解从FIX引擎发送到交易方的管理消息。这通常对应用程序没有用处，但它可以让你进行与管理消息相关的日志记录。注意：FIX::Message 不是常量，这允许你在发送管理消息之前向其添加字段。
  • toApp：正在发送给对手方的应用程序消息时进行的回调。如果在这个函数中抛出一个 DoNotSend 异常，应用程序将不会发送消息。这可用于取消重新发送一些不必要的消息，比如与当前市场不再相关的订单。注意：FIX::Message 不是常量，这允许你在发送管理消息之前向其添加字段。
    • 抛出 DoNotSend 异常并将消息的 PossDupFlag 设置为 true：a sequence reset will be sent in place of the message.（序列号将被重置为这个要发送的消息的序列号？）
    • 抛出 DoNotSend 异常并将消息的 PossDupFlag 设置为 false：不会发送消息。
  • fromAdmin：当管理消息从交易方发送到 FIX 引擎时通知您。这对于对登录消息(如验证密码)进行额外的验证非常有用。在函数中抛出 RejectLogon 异常将断开对方的连接。
  • fromApp：接收应用程序级请求。如果您的应用程序是一个卖方OMS，您将从函数中获得的新订单请求；如果你是买方，你会在这里拿到你的执行报告。
    • 如果抛出 FieldNotFound 异常，对方将收到一个 Reject消息，表示缺少一个条件要求的字段。当试图检索丢失的字段时，Message 类将抛出此异常，因此很少需要显式地抛出。
    • 如果抛出 UnsupportedMessageType 异常，对方将收到一个 Reject消息，通知他们您的应用程序无法处理这些类型的消息。
    • 如果字段包含您不支持的值，也会抛出 IncorrectTagValue。

如果应用程序在多个会话之间共享资源，则必须同步这些资源；可以用SynchronizedApplication 类来自动同步应用程序中的所有函数调用，各种 MessageCracker 类可用于将通用消息结构解析为特定的 FIX 消息。 

2.2 SynchronizedApplication

与Application 的区别：通过 Mutex 在回调的时候保证这一次只有一个线程访问应用程序的代码，这样对性能有影响。

/**
* This is a special implementation of the Application interface that takes
* in another Application interface and synchronizes all of its callbacks. This
* will guarantee that only one thread will access the applications code at a time.
*
* This class is a great convenience for writing applications where you
* don't want to worry about synchronization. There is of course a tradeoff
* in that you may be synchronizing more than you need to. There is also a very
* minor performance penalty due to the extra virtual table lookup.
*/
class SynchronizedApplication : public Application
{
public:
  SynchronizedApplication( Application& app ) : m_app( app ) {}

  void onCreate( const SessionID& sessionID )
  { Locker l( m_mutex ); app().onCreate( sessionID ); }
  void onLogon( const SessionID& sessionID )
  { Locker l( m_mutex ); app().onLogon( sessionID ); }
  void onLogout( const SessionID& sessionID )
  { Locker l( m_mutex ); app().onLogout( sessionID ); }
  void toAdmin( Message& message, const SessionID& sessionID )
  { Locker l( m_mutex ); app().toAdmin( message, sessionID ); }
  void toApp( Message& message, const SessionID& sessionID )
  throw( DoNotSend )
  { Locker l( m_mutex ); app().toApp( message, sessionID ); }
  void fromAdmin( const Message& message, const SessionID& sessionID )
  throw( FieldNotFound, IncorrectDataFormat, IncorrectTagValue, RejectLogon )
  { Locker l( m_mutex ); app().fromAdmin( message, sessionID ); }
  void fromApp( const Message& message, const SessionID& sessionID )
  throw( FieldNotFound, IncorrectDataFormat, IncorrectTagValue, UnsupportedMessageType )
  { Locker l( m_mutex ); app().fromApp( message, sessionID ); }

  Mutex m_mutex;

  Application& app() { return m_app; }
  Application& m_app;
};

2.3. FIX::NullApplication实现

FIX::NullApplication 主要用于不想要实现所有回调接口的场景中，可以继承该类。

class NullApplication : public Application
{
    void onCreate( const SessionID& ) {}
    void onLogon( const SessionID& ) {}
    void onLogout( const SessionID& ) {}
    void toAdmin( Message&, const SessionID& ) {}

    void toApp( Message&, const SessionID& ) 
        EXCEPT ( DoNotSend ) {}
    void fromAdmin( const Message&, const SessionID& )
        EXCEPT ( FieldNotFound, IncorrectDataFormat, IncorrectTagValue, RejectLogon ) {}
    void fromApp( const Message&, const SessionID& )
        EXCEPT ( FieldNotFound, IncorrectDataFormat, IncorrectTagValue, UnsupportedMessageType ) {}
};

 

2.4 SessionSettings

FIX配置使用FIX::SessionSettings读取FIX Session配置文件并传递给QuickFIX框架。

一个FIX应用能够管理多个FIX Session，每一个Session能够采用相同的FIX协议版本，也能够采用不一样的版本。即便采用的是相同的FIX协议版本，不一样FIX Session间也能够有FIX协议细节的差别，经过绑定FIX Session与FIX协议字典的方式来实现，即在Session配置文件中[Session]配置项中使用DataDictionary选项指定相应FIX字典文件来实现。

FIX::SessionSettings settings("sessionConfig.ini");

应用如何实现的管理多session？看Initiator/Acceptor源码可以明白

  class{
'''
  typedef std::set < SessionID > SessionIDs;
  typedef std::map < SessionID, int > SessionState;
  typedef std::map < SessionID, Session* > Sessions;

  Sessions m_sessions;
  SessionIDs m_sessionIDs;
  SessionState m_sessionState;
...
}

 三个map记录id、状态、具体对象。

2.5 FileStoreFactory

QuickFIX提供了存储消息到文件的类FIX::FileStoreFactory。消息文件存储的路径在Session配置中指定。具体配置下文提到。

FIX::FileStoreFactory storeFactory(settings);

2.4 MessageStoreFactory

QuickFIX提供了给Fix Session持久化类型(如文件存储、数据存储，存储内容包括状态、建立时间、消息及其本身维护的发送序列号和接收序列号等）。
如果开发者要自定义持久化方式，也可以自己实现MessageStoreFactory，而且自定义一种MessageStore的ide。

/**
 * This interface must be implemented to create a MessageStore.
 */
class MessageStoreFactory
{
public:
  virtual ~MessageStoreFactory() {}
  virtual MessageStore* create( const SessionID& ) = 0;
  virtual void destroy( MessageStore* ) = 0;
};

2.5 FIX::FileLogFactory

QuickFIX提供了存储全部日志事件到文件的类FIX::FileLogFactory。

2.6 FIX::Message

QuickFIX中定义了不一样FIX协议版本消息的基类FIX::Message，用于定义FIX消息的通用结构，不一样的FIX消息版本的消息定义在不一样的FIX命名空间内定义，如FIX42::Message。FIX::MessageCracker则继承了全部不一样FIX协议版本的MessageCracker类，接收消息后生成具体FIX协议Message对象实现对消息进行处理。

2.7 FIX::Acceptor


FIX::Acceptor用于创建和管理本Acceptor的Session。

具体Session的TCP连接管理、数据读写由具体的SocketAcceptor、SSLSocketAcceptor、ThreadedSocketAcceptor、ThreadedSSLSocketAcceptor实现。

FIX::Acceptor* acceptor = new FIX::SocketAcceptor(application, storeFactory, 
                                                  settings, logFactory);


2.8 FIX::Initiator


FIX::Initiator用于创建和管理本Initiator支持的Session。

具体Session的TCP连接管理、数据读写由具体的SocketInitiator、SSLSocketInitiator、ThreadedSocketInitiator、ThreadedSSLSocketInitiator实现。

FIX::Initiator * initiator = new FIX::SocketInitiator(application,  storeFactory,  settings, logFactory);

三、创建应用

我们根据第二章的内容创建一个应用（主体见2.1）

.h

#ifndef EXECUTOR_APPLICATION_H
#define EXECUTOR_APPLICATION_H

#include "quickfix/Application.h"
#include "quickfix/MessageCracker.h"
#include "quickfix/Values.h"
#include "quickfix/Utility.h"
#include "quickfix/Mutex.h"

#include "quickfix/fix40/NewOrderSingle.h"
#include "quickfix/fix41/NewOrderSingle.h"
#include "quickfix/fix42/NewOrderSingle.h"
#include "quickfix/fix43/NewOrderSingle.h"
#include "quickfix/fix44/NewOrderSingle.h"
#include "quickfix/fix50/NewOrderSingle.h"

class Application
: public FIX::Application, public FIX::MessageCracker
{
public:
  Application() : m_orderID(0), m_execID(0) {}

  // Application overloads
  void onCreate( const FIX::SessionID& );
  void onLogon( const FIX::SessionID& sessionID );
  void onLogout( const FIX::SessionID& sessionID );
  void toAdmin( FIX::Message&, const FIX::SessionID& );
  void toApp( FIX::Message&, const FIX::SessionID& )
    EXCEPT( FIX::DoNotSend );
  void fromAdmin( const FIX::Message&, const FIX::SessionID& )
    EXCEPT( FIX::FieldNotFound, FIX::IncorrectDataFormat, FIX::IncorrectTagValue, FIX::RejectLogon );
  void fromApp( const FIX::Message& message, const FIX::SessionID& sessionID )
    EXCEPT( FIX::FieldNotFound, FIX::IncorrectDataFormat, FIX::IncorrectTagValue, FIX::UnsupportedMessageType );

  // MessageCracker overloads
  void onMessage( const FIX40::NewOrderSingle&, const FIX::SessionID& );
  void onMessage( const FIX41::NewOrderSingle&, const FIX::SessionID& );
  void onMessage( const FIX42::NewOrderSingle&, const FIX::SessionID& );
  void onMessage( const FIX43::NewOrderSingle&, const FIX::SessionID& );
  void onMessage( const FIX44::NewOrderSingle&, const FIX::SessionID& );
  void onMessage( const FIX50::NewOrderSingle&, const FIX::SessionID& );

  std::string genOrderID() {
    std::stringstream stream;
    stream << ++m_orderID;
    return stream.str();
  }
  std::string genExecID() {
    std::stringstream stream;
    stream << ++m_execID;
    return stream.str();
  }
private:
  int m_orderID, m_execID;
};

#endif

.cpp

#include "quickfix/config.h"

#include "Application.h"
#include "quickfix/Session.h"

#include "quickfix/fix40/ExecutionReport.h"
#include "quickfix/fix41/ExecutionReport.h"
#include "quickfix/fix42/ExecutionReport.h"
#include "quickfix/fix43/ExecutionReport.h"
#include "quickfix/fix44/ExecutionReport.h"
#include "quickfix/fix50/ExecutionReport.h"

void Application::onCreate( const FIX::SessionID& sessionID ) {}
void Application::onLogon( const FIX::SessionID& sessionID ) {}
void Application::onLogout( const FIX::SessionID& sessionID ) {}
void Application::toAdmin( FIX::Message& message,
                           const FIX::SessionID& sessionID ) {}
void Application::toApp( FIX::Message& message,
                         const FIX::SessionID& sessionID )
EXCEPT( FIX::DoNotSend ) {}

void Application::fromAdmin( const FIX::Message& message,
                             const FIX::SessionID& sessionID )
EXCEPT( FIX::FieldNotFound, FIX::IncorrectDataFormat, FIX::IncorrectTagValue, FIX::RejectLogon ) {}

void Application::fromApp( const FIX::Message& message,
                           const FIX::SessionID& sessionID )
EXCEPT( FIX::FieldNotFound, FIX::IncorrectDataFormat, FIX::IncorrectTagValue, FIX::UnsupportedMessageType )
{ crack( message, sessionID ); }

void Application::onMessage( const FIX40::NewOrderSingle& message,
                             const FIX::SessionID& sessionID )
{
  FIX::Symbol symbol;
  FIX::Side side;
  FIX::OrdType ordType;
  FIX::OrderQty orderQty;
  FIX::Price price;
  FIX::ClOrdID clOrdID;
  FIX::Account account;

  message.get( ordType );

  if ( ordType != FIX::OrdType_LIMIT )
    throw FIX::IncorrectTagValue( ordType.getField() );

  message.get( symbol );
  message.get( side );
  message.get( orderQty );
  message.get( price );
  message.get( clOrdID );

  FIX40::ExecutionReport executionReport = FIX40::ExecutionReport
      ( FIX::OrderID( genOrderID() ),
        FIX::ExecID( genExecID() ),
        FIX::ExecTransType( FIX::ExecTransType_NEW ),
        FIX::OrdStatus( FIX::OrdStatus_FILLED ),
        symbol,
        side,
        orderQty,
        FIX::LastShares( orderQty ),
        FIX::LastPx( price ),
        FIX::CumQty( orderQty ),
        FIX::AvgPx( price ) );

  executionReport.set( clOrdID );

  if( message.isSet(account) )
    executionReport.setField( message.get(account) );

  try
  {
    FIX::Session::sendToTarget( executionReport, sessionID );
  }
  catch ( FIX::SessionNotFound& ) {}
}

代码很简单，唯一可能值得注意的两点：

1、一般情况下，对于FIX应用开发，除了实现FIX::Application接口，还需要重新实现FIX::MessageCracker从具体FIX协议版本实现继承来的onMessage方法，所以我们一般这么写：

class FIXApplication: public FIX::Application, public FIX::MessageCracker

2、crack接口，他根据message类型匹配到你实现的具体onMessage接口上。

  void crack( const Message& message,
              const SessionID& sessionID )
  {
    const FIX::BeginString& beginString = 
      FIELD_GET_REF( message.getHeader(), BeginString );

    crack( message, sessionID, beginString );
  }

  void crack( const Message& message,
              const SessionID& sessionID,
              const BeginString& beginString )
  {
    if ( beginString == BeginString_FIX40 )
      ((FIX40::MessageCracker&)(*this)).crack((const FIX40::Message&) message, sessionID);
    else if ( beginString == BeginString_FIX41 )
      ((FIX41::MessageCracker&)(*this)).crack((const FIX41::Message&) message, sessionID);
    else if ( beginString == BeginString_FIX42 )
      ((FIX42::MessageCracker&)(*this)).crack((const FIX42::Message&) message, sessionID);
    else if ( beginString == BeginString_FIX43 )
      ((FIX43::MessageCracker&)(*this)).crack((const FIX43::Message&) message, sessionID);
    else if ( beginString == BeginString_FIX44 )
      ((FIX44::MessageCracker&)(*this)).crack((const FIX44::Message&) message, sessionID);
    else if ( beginString == BeginString_FIXT11 )
    {
      if( message.isAdmin() )
      {
        ((FIXT11::MessageCracker&)(*this)).crack((const FIXT11::Message&) message, sessionID);
      }
      else
      {
'''
      }
    }
  }

四、发送方

Acceptor，也可以称作为 Server，就是服务端。客户端从各地发来交易或者行情请求后，由这些服务器端接收，并进一步送给决策端进行验证、决策，并由此服务器返回相应的结果。大概的回复可能是这样的：

  • 行情请求（35=V）——行情报价回复（35=W）；
  • 新建订单（35=D）——订单回复（35=8）
  • 撤销订单（35=F）——订单回复（35=8）或者拒绝（35=9）

搭建一个服务端非常的简单，只需要两个类：一个类负责初始化、启动和关停服务（见2.7 FIX::Acceptor）；另一个类负责服务，即收发消息（见2.1 Application）。

在第三章我们已经实现了收发消息的类，接下来我们实现Acceptor，万里长征就走完了一大半。

（1）创建FIX Session配置对象FIX::SessionSettings settings(sessionFile);
（2）创建FIX应用：Application application;
（3）创建日志工厂：LogFactory logFactory(settings);
（4）创建消息存储文件工厂：FIX::FileStoreFactory storeFactory(settings);
（5）创建Acceptor服务端：acceptor = new FIX::SocketAcceptor ( application, storeFactory, 
                                         settings, logFactory );
（6）启动：acceptor->start();

#include "config.h"
#include "quickfix/FileStore.h"
#include "quickfix/SocketAcceptor.h"
#include "quickfix/Log.h"
#include "quickfix/SessionSettings.h"
#include "Application.h"
#include <string>
#include <iostream>
#include <fstream>
 
int main( int argc, char** argv )
{
  if ( argc < 2 )
  {
    std::cout << "usage: " << argv[ 0 ]
    << " FILE." << std::endl;
    return 0;
  }
 
  std::string file = argv[ 1 ];
  FIX::Acceptor * acceptor = 0;
  try
  {
    FIX::SessionSettings settings( file );
 
    Application application;
    FIX::FileStoreFactory storeFactory( settings );
    FIX::ScreenLogFactory logFactory( settings );
    acceptor = new FIX::SocketAcceptor ( application, storeFactory, 
                                         settings, logFactory );
    acceptor->start();
    // dosomething wait();
    acceptor->stop();
    delete acceptor;
    return 0;
  }
  catch ( std::exception & e )
  {
    std::cout << e.what() << std::endl;
    delete acceptor;
    return 1;
  }
}

五、接收方

Initiator，也可以称作为 Client，就是分散在各个地方的交易机（客户端）。业务员在上面操作以后，客户端会向服务器发送请求。请求多种多样，基本常用的有：行情请求（35=V），新建订单（35=D），撤销订单（35=F）。

搭建Initiator和服务端基本一样，不过多解释。（当然，买方卖方的application逻辑肯定不一样，这里只是给你一个代码框架，希望你注意）

#include "config.h"
#include "quickfix/FileStore.h"
#include "quickfix/SocketInitiator.h"
#include "quickfix/SessionSettings.h"
#include "quickfix/Log.h"
#include "Application.h"
#include <string>
#include <iostream>
#include <fstream>
 
int main( int argc, char** argv )
{
  if ( argc < 2 )
  {
    std::cout << "usage: " << argv[ 0 ]
    << " FILE." << std::endl;
    return 0;
  }
 
  std::string file = argv[ 1 ];
 
  FIX::Initiator * initiator = 0;
  try
  {
    FIX::SessionSettings settings( file );
 
    Application application;
    FIX::FileStoreFactory storeFactory( settings );
    FIX::ScreenLogFactory logFactory( settings );
    initiator = new FIX::SocketInitiator( application, storeFactory, 
                                          settings, logFactory );
    initiator->start();
    application.run();
    initiator->stop();
    delete initiator;
 
    return 0;
 
  }
  catch ( std::exception & e )
  {
    std::cout << e.what();
    delete initiator;
    return 1;
  }
}

六、进一步的操作

通过上文，我们已经了解了quickfix大概的代码框架是什么样子的，接下来认识一些进一步的操作，以便我们可以把这个小demo真的做成一个功能。

 6.1 配置文件

配置文件，简化来讲，有两个：一个是程序调用的properties，另一个是传输时候的字典，相当于“密码本”。
 

先看一下文件内容

6.1.1 quickfix.properties

#quickfix-server.properties
[default]
# 这些字段接的改成你的设置
FileStorePath=fileStore
SocketConnectHost=XXX.XXX.XXX.XXX
SocketConnectPort=XXXXX
TargetCompID=QUICKFIX_ACCEPTOR

# 以下字段可以不改
ConnectionType=initiator
HeartBtInt=30
ReconnectInterval=10
FileLogPath=log
UseDataDictionary=N
DataDictionary=src/main/resources/FIX44.modified.xml
ContinueInitializationOnError=Y
BeginString=FIX.4.4
StartTime=00:00:00
EndTime=23:00:00
ResetOnLogon=Y
ResetSeqNumFlag=Y
MaxMessagesInResendRequest=1

[session]
SenderCompID=QUICKFIX_INITIATOR1

[session]
SenderCompID=QUICKFIX_INITIATOR2

能看到，配置被分为3大类：开头的[default]，然后是两个[session]。

session的意思是，你作为发送方时，不一定发给一个人。或者你作为接收方时，不一定只接收一个人的信息。每个session下面配了不同的SenderCompID，意思就是可能会有很多Sender给我发消息，因此我要根据不同的SenderComID来区别不同的发送方。这个名字可以随便起，只要保证收发双方一致。

其他公用的部分可以放在[default]里面，其中：

  • FileStorePath是存储消息和事件的文件夹，确保一定要有写的权限；
  • SocketConnectHost和SocketConnectPort 是你Accepter的IP地址和端口；
  • TargetCompID 是你发的消息由谁来接收（和SenderCompID对应）；
  • ConnectionType是你扮演的角色，有initiator和acceptor两种；
  • HeartBtInt是心跳间隔。

更多配置直接查阅官网。

讲到这里，我害怕你还是不会写两边的配置，所以我复制一份

[default]
# 这些字段记得改成你的设置
FileStorePath=fileStore
SocketConnectHost=***
SocketConnectPort=***
TargetCompID=QUICKFIX_ACCEPTOR

# 以下字段可以不改
ConnectionType=initiator
HeartBtInt=30
ReconnectInterval=10
FileLogPath=log
UseDataDictionary=N
DataDictionary=src/main/resources/FIX44.modified.xml
ContinueInitializationOnError=Y
BeginString=FIX.4.4
StartTime=00:00:00
EndTime=23:00:00
ResetOnLogon=Y
ResetSeqNumFlag=Y
MaxMessagesInResendRequest=1

[session]
SenderCompID=QUICKFIX_INITIATOR1

[session]
SenderCompID=QUICKFIX_INITIATOR2
#quickfix-server.properties
[default]
# 这些字段记得改成你的设置
FileStorePath=fileStore
SocketAcceptAddress=***
SocketAcceptPort=***
SenderCompID=QUICKFIX_ACCEPTOR

# 以下字段可以不改
ConnectionType=acceptor
HeartBtInt=30
#ReconnectInterval=10
FileLogPath=log
DataDictionary=src/main/resources/FIX44.modified.xml
ContinueInitializationOnError=Y
BeginString=FIX.4.4
StartTime=00:00:00
EndTime=23:00:00
ResetOnLogon=Y
ResetSeqNumFlag=Y
MaxMessagesInResendRequest=1
SocketReuseAddress=Y
UseDataDictionary=Y

[session]
TargetCompID=QUICKFIX_INITIATOR1

[session]
TargetCompID=QUICKFIX_INITIATOR2

6.1.2 FIX44.modified.xml

在实际业务中，我们会对字典进行一定修改，比如让某些字段从“必须有”到“可以有”，增减某些消息里面的某些字段，甚至定义自己的新消息。在这个时候，我们就可以在原有FIX44.xml的基础上维护我们自己的“密码本”，取个名字：FIX44.modified.xml。

每一个消息都在message的标签内：

  • name="MarketDataRequestReject" 表示名字；
  • msgtype="Y" 表示他的类别，在传输的时候会表现为“35=Y”；
  • msgcat="app" 表示他是App层的传输。另外一个是Admin；
  • field name="MDReqID" required="N" 表示这个消息有个字段叫MDReqID，并且在传输的时候不是必须的。如果一个字段定义为required="Y"但是实际没有传，那么这条消息就会被自动拒收，并返回“35=3”的消息高速对方；
  • group name="NoAltMDSource" 表示里面有个重复组，即一个消息中可能多次出现同一个字段（比如我在查询行情的时候可能查询多个产品的行情），那么这可以“重复”的字段就必须定义在重复组里。

更多信息查阅官网

6.2 官网需要查看的东西

我还希望你可以查看官网的第三章和第四章，这可以帮助你学习quickfix的各种细节用法，包括如何收发消息、重复组的使用、自定义字段使用、他们自带的一套测试框架等等

 七、常见的错误解答&q&a

第一条消息由Initiator 发出，但是在Acceptor端没有看到接收的痕迹。

可能是Initiator端在发送第一条消息的时候过快，以至于抢在了登录之前。

SessionNotFound

一般都是你配置错误导致找不到session，我们前期讲过，一个Session由3个基本要素构成：消息头、发送方、接收方。任何一方有错误都会导致上述的SessionNotFound问题。

比如最常见的错误是：Properties 文件中IP地址和端口不对或被占用？

toApp 接口中，抛出 DoNoSend 异常会对序列号造成影响吗？

Application::toApp() 接口的回调发生在序列号递增（Session::persist()）之前，所以不会对序列号造成影响。

SendingTime Accuracy Problem

因为收发双方的时间不对应，根据Fix协议，默认双方时差在30s以上时就会爆出这种时钟不同步的问题。

解决办法1：配置你的机器，使时间一致。

解决办法2：通过设置properties文件，配置CheckLatency=N，这样就不会去做时钟同步检查。


Logout is Called

在建立链接的时候，立即收到Logout is Called的消息，除此之外没有其他提示。

如果不是网络问题，那就是对方拒绝了跟你的通信，但出于安全考虑，又不想暴露原因，就会抛出这么一个消息。

可能的原因有：

  1. 没有使用SSL链接方式；
  2. Logon时候对方需求在消息中包含用户名和密码，但你没有写；
  3. SenderCompID没配好，是对方不能识别或者没有记录在案的ID。

 

文章来源: fantianzuo.blog.csdn.net，作者：兔老大RabbitMQ，版权归原作者所有，如需转载，请联系作者。

原文链接：fantianzuo.blog.csdn.net/article/details/126179473

【版权声明】本文为华为云社区用户转载文章，如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱： cloudbbs@huaweicloud.com
TCP/IP
  • 点赞
  • 收藏
  • 关注作者

评论（0）

0/1000
抱歉，系统识别当前为高风险访问，暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称，即可参与社区互动！

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

确认 取消

加入云驻计划，成为创作者

  • 华为云周边好礼
  • 免费体验产品
  • 特殊身份标识
  • 线下官方门票
  • 内部专家零距离
  • 与10000+优质创作者共同成长
立即加入