创建一个springboot项目 需要包含quickfixj-spring-boot-starter、kafka，使用quickfixj-spring-boot-starte接收FIX连接消息，要求根据fix消息种类进行分类发送到kafka不同的队列中

好的，我了解了你的要求。首先，你需要在Maven或Gradle中添加quickfixj-spring-boot-starter和kafka的依赖。在pom.xml文件中，你可以添加以下依赖：

<dependency>
    <groupId>org.quickfixj</groupId>
    <artifactId>quickfixj-spring-boot-starter</artifactId>
    <version>2.0.1</version>
</dependency>

<dependency>
    <groupId>org.springframework.kafka</groupId>
    <artifactId>spring-kafka</artifactId>
    <version>2.5.0.RELEASE</version>
</dependency>

接下来，你需要在你的Spring Boot应用程序中配置QuickFIX/J。在application.properties文件中，你可以添加以下配置：

# QuickFIX/J Settings
quickfixj.applicationName=MyFIXApplication
quickfixj.config=classpath:quickfixj.cfg

# Kafka Settings
spring.kafka.bootstrap-servers=localhost:9092
spring.kafka.producer.value-serializer=org.apache.kafka.common.serialization.StringSerializer

其中，quickfixj.applicationName是你的FIX应用程序的名称，quickfixj.config是你的QuickFIX/J配置文件的位置。在这个示例中，我们将配置文件置于classpath下。

接下来，你需要编写一个FIX消息处理器，根据消息类型将消息发送到不同的Kafka队列中。你可以定义一个实现quickfix.Application接口的类，并在其中实现onMessage()方法。

import org.quickfixj.Message;
import org.quickfixj.QFJException;
import org.quickfixj.SessionID;
import org.quickfixj.message.ExecutionReport;
import org.quickfixj.message.MessageCracker;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Component;

@Component
public class MyFIXApplication extends MessageCracker implements quickfix.Application {

    @Autowired
    private KafkaTemplate<String, String> kafkaTemplate;

    @Override
    public void onCreate(SessionID sessionId) {
        System.out.println("Session created: " + sessionId);
    }

    @Override
    public void onLogon(SessionID sessionId) {
        System.out.println("Logon successful: " + sessionId);
    }

    @Override
    public void onLogout(SessionID sessionId) {
        System.out.println("Logout successful: " + sessionId);
    }

    @Override
    public void toAdmin(Message message, SessionID sessionId) {
        // Do nothing
    }

    @Override
    public void toApp(Message message, SessionID sessionId) throws DoNotSend {
        crack(message, sessionId);
    }

    @Override
    public void fromAdmin(Message message, SessionID sessionId) throws FieldNotFound, IncorrectDataFormat, IncorrectTagValue, RejectLogon {
        // Do nothing
    }

    @Override
    public void fromApp(Message message, SessionID sessionId) throws FieldNotFound, IncorrectDataFormat, IncorrectTagValue, UnsupportedMessageType {
        crack(message, sessionId);
    }

    public void onMessage(ExecutionReport message, SessionID sessionId) throws FieldNotFound, UnsupportedMessageType, IncorrectTagValue {
        String topicName;
        switch (message.getOrdStatus().getValue()) {
            case OrdStatus.NEW:
                topicName = "new-orders";
                break;
            case OrdStatus.FILLED:
                topicName = "filled-orders";
                break;
            case OrdStatus.REJECTED:
                topicName = "rejected-orders";
                break;
            default:
                throw new IncorrectTagValue(39);
        }
        kafkaTemplate.send(topicName, message.toString());
    }
}

在这个示例中，我们使用了Spring Boot Kafka的KafkaTemplate来发送消息到Kafka队列中。根据FIX消息的OrdStatus字段，我们将消息发送到不同的Kafka队列中。

最后，你需要在你的Spring Boot应用程序中启用QuickFIX/J。你可以在你的启动类中添加@ImportResource注解，并在其中指定你的QuickFIX/J配置文件的位置。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ImportResource;

@SpringBootApplication
@ImportResource("classpath:quickfixj.xml")
public class MyApplication {

    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }

}

在这个示例中，我们将QuickFIX/J配置文件的位置置于classpath下，并将其命名为quickfixj.xml。

这样，你就可以创建一个Spring Boot应用程序，使用quickfixj-spring-boot-starter接收FIX连接消息，并根据消息类型将消息发送到Kafka不同的队列中了。