用Java代码实现存在工单系统A和任务执行系统B，用户在A系统提交的工单会上送到B系统进行执行，在B系统中，上报的工单会按队列的方式顺序执行且执行完成之后不会回调通知A系统执行结果，A系统可以获取结果

可以考虑使用消息队列来实现A系统和B系统之间的通信。具体实现方式如下：

1. 在A系统中，当用户提交工单时，将工单信息发送到消息队列中，消息队列可以选择使用Apache Kafka或RabbitMQ等。

2. 在B系统中，启动一个消费者进程，用于监听消息队列中的工单信息，当有新的工单信息到达时，消费者进程会将其取出并进行相应的任务执行。

3. 在B系统中，执行完工单之后，将工单执行结果保存到数据库中。

4. 在A系统中，当需要获取工单执行结果时，向B系统发送请求，B系统查询数据库并将结果返回给A系统。

示例Java代码如下：

在A系统中发送工单信息到消息队列：

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.common.serialization.StringSerializer;

import java.util.Properties;

public class WorkOrderProducer {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put("bootstrap.servers", "localhost:9092");
        props.put("key.serializer", StringSerializer.class.getName());
        props.put("value.serializer", StringSerializer.class.getName());

        KafkaProducer<String, String> producer = new KafkaProducer<>(props);

        String workOrder = "{\"id\":1, \"content\":\"这是一条工单信息\"}";
        ProducerRecord<String, String> record = new ProducerRecord<>("work_order_topic", workOrder);

        producer.send(record);
        producer.close();
    }
}

在B系统中监听消息队列并处理工单信息：

import org.apache.kafka.clients.consumer.*;
import org.apache.kafka.common.serialization.StringDeserializer;

import java.time.Duration;
import java.util.Collections;
import java.util.Properties;

public class WorkOrderConsumer {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put("bootstrap.servers", "localhost:9092");
        props.put("group.id", "work_order_group");
        props.put("key.deserializer", StringDeserializer.class.getName());
        props.put("value.deserializer", StringDeserializer.class.getName());

        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
        consumer.subscribe(Collections.singletonList("work_order_topic"));

        while (true) {
            ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
            for (ConsumerRecord<String, String> record : records) {
                String workOrder = record.value();
                // 处理工单信息
                System.out.println("处理工单信息：" + workOrder);
            }
        }
    }
}

在B系统中执行工单并保存执行结果到数据库：

import java.sql.*;

public class WorkOrderExecutor {
    public static void execute(String workOrder) {
        // 执行工单任务
        System.out.println("执行工单任务：" + workOrder);

        // 保存工单执行结果到数据库
        Connection conn = null;
        PreparedStatement stmt = null;
        try {
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/work_order_db", "root", "123456");
            stmt = conn.prepareStatement("INSERT INTO work_order_result (work_order_id, result) VALUES (?, ?)");
            stmt.setInt(1, 1);
            stmt.setString(2, "工单执行成功");
            stmt.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            if (stmt != null) {
                try {
                    stmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

在A系统中获取工单执行结果：

import java.sql.*;

public class WorkOrderResultGetter {
    public static void main(String[] args) {
        // 获取工单执行结果
        Connection conn = null;
        PreparedStatement stmt = null;
        ResultSet rs = null;
        try {
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/work_order_db", "root", "123456");
            stmt = conn.prepareStatement("SELECT result FROM work_order_result WHERE work_order_id = ?");
            stmt.setInt(1, 1);
            rs = stmt.executeQuery();
            while (rs.next()) {
                String result = rs.getString("result");
                System.out.println("工单执行结果：" + result);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            if (rs != null) {
                try {
                    rs.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (stmt != null) {
                try {
                    stmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}