如何在Drools规则执行时按需建立数据库连接获取数据？

嘿，我来给你梳理下在Drools里实现数据库连接、规则执行时按需取数的几种常用方案，都是实际项目里验证过的，你可以根据自己的场景来选：

如果你的项目比较简单，不想引入太多依赖，可以写个数据库工具类，在规则里直接调用获取连接。

首先搞个DB工具类，一定要用连接池（别直接每次新建连接，会搞崩数据库的）：

public class DBUtil {
    // 用HikariCP连接池示例，比原生DriverManager靠谱多了
    private static final HikariDataSource DATA_SOURCE;

    static {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl("jdbc:mysql://localhost:3306/your_db");
        config.setUsername("root");
        config.setPassword("your_pwd");
        config.setDriverClassName("com.mysql.cj.jdbc.Driver");
        config.setMaximumPoolSize(10); // 根据并发量调整
        DATA_SOURCE = new HikariDataSource(config);
    }

    public static Connection getConnection() throws SQLException {
        return DATA_SOURCE.getConnection();
    }
}

然后在Drools规则里调用这个工具类取数：

rule "Fetch Customer Discount On Demand"
when
    // 触发规则的条件：比如存在待处理且未设置折扣的订单
    $order: Order(status == "PENDING", discount == null)
then
    try (Connection conn = DBUtil.getConnection()) {
        String sql = "SELECT discount FROM customer_discount WHERE customer_id = ?";
        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
            pstmt.setLong(1, $order.getCustomerId());
            try (ResultSet rs = pstmt.executeQuery()) {
                if (rs.next()) {
                    double discount = rs.getDouble("discount");
                    $order.setDiscount(discount);
                    update($order); // 更新工作区里的对象，触发后续相关规则
                }
            }
        }
    } catch (SQLException e) {
        // 别光打堆栈，最好用日志框架记录详情
        log.error("Failed to fetch discount for customer {}", $order.getCustomerId(), e);
        // 可以抛RuntimeException让规则引擎处理，或者设置默认值
        throw new RuntimeException("Discount fetch failed", e);
    }
end

这个方案适合快速实现，但代码耦合度高，适合小项目或者临时场景。

如果你的项目本来就用Spring，那用Spring的数据源和依赖注入会优雅很多，还能享受到连接池、事务管理这些特性。

第一步，在Spring配置里加数据源（比如application.yml）：

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/your_db
    username: root
    password: your_pwd
    driver-class-name: com.mysql.cj.jdbc.Driver
    type: com.zaxxer.hikari.HikariDataSource
    hikari:
      maximum-pool-size: 15

第二步，写个数据访问的Service，封装DB操作：

@Service
public class DiscountService {
    private final JdbcTemplate jdbcTemplate;

    // 构造函数注入（比@Autowired更推荐）
    public DiscountService(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    public Double getDiscountByCustomerId(Long customerId) {
        String sql = "SELECT discount FROM customer_discount WHERE customer_id = ?";
        // 若没数据会抛异常，也可以用query加空值判断，按需选择
        return jdbcTemplate.queryForObject(sql, new Object[]{customerId}, Double.class);
    }
}

第三步，把Spring的Service Bean设置为Drools的全局变量，这样规则里就能直接引用：

// 在初始化KieSession的地方（比如Spring的@Bean或者业务代码里）
@Autowired
private KieContainer kieContainer;
@Autowired
private DiscountService discountService;

public void executeRules(Order order) {
    KieSession kieSession = kieContainer.newKieSession();
    // 设置全局变量，规则里的声明要和这里的名字、类型对应
    kieSession.setGlobal("discountService", discountService);
    // 把业务对象放入工作区
    kieSession.insert(order);
    // 执行规则
    kieSession.fireAllRules();
    kieSession.dispose();
}

然后在规则里使用这个全局Service：

// 声明全局变量，要和Java代码中设置的一致
global com.yourcompany.service.DiscountService discountService;

rule "Fetch Discount via Spring Service"
when
    $order: Order(status == "PENDING", discount == null)
then
    try {
        Double discount = discountService.getDiscountByCustomerId($order.getCustomerId());
        if (discount != null) {
            $order.setDiscount(discount);
            update($order);
        }
    } catch (DataAccessException e) {
        log.error("Error getting discount for customer {}", $order.getCustomerId(), e);
        // 给个默认折扣或者标记异常状态
        $order.setDiscount(0.0);
        $order.setStatus("DISCOUNT_FETCH_FAILED");
        update($order);
    }
end

这个方案解耦性好，维护方便，还能利用Spring的事务、缓存等特性，绝对是企业级项目的首选。

如果你的项目用了Drools的jBPM流程引擎，或者想把DB操作封装成可复用的组件，可以自定义WorkItemHandler。

先写个自定义的WorkItemHandler：

public class DBFetchWorkItemHandler extends AbstractWorkItemHandler {
    private final DataSource dataSource;

    public DBFetchWorkItemHandler(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    @Override
    public void executeWorkItem(WorkItem workItem, WorkItemManager manager) {
        // 从工作项参数里获取需要的值
        Long customerId = (Long) workItem.getParameter("customerId");
        String sql = (String) workItem.getParameter("sql");

        try (Connection conn = dataSource.getConnection()) {
            try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
                pstmt.setLong(1, customerId);
                try (ResultSet rs = pstmt.executeQuery()) {
                    if (rs.next()) {
                        Double discount = rs.getDouble("discount");
                        // 把结果放回工作项，供后续逻辑使用
                        workItem.getResults().put("discount", discount);
                    }
                }
            }
        } catch (SQLException e) {
            throw new RuntimeException("DB fetch operation failed", e);
        }

        // 完成工作项，通知管理器
        manager.completeWorkItem(workItem.getId(), workItem.getResults());
    }

    @Override
    public void abortWorkItem(WorkItem workItem, WorkItemManager manager) {
        // 可以在这里做中止逻辑，比如关闭未释放的连接
        manager.abortWorkItem(workItem.getId());
    }
}

然后注册这个Handler到KieSession：

@Autowired
private DataSource dataSource;

public void setupKieSession() {
    KieSession kieSession = kieContainer.newKieSession();
    WorkItemManager workItemManager = kieSession.getWorkItemManager();
    // 注册自定义的工作项处理器，名字叫DBFetch
    workItemManager.registerWorkItemHandler("DBFetch", new DBFetchWorkItemHandler(dataSource));
}

最后在规则里调用这个工作项：

rule "Use DBFetch WorkItem to Get Discount"
when
    $order: Order(status == "PENDING")
then
    // 创建工作项，设置参数
    WorkItem workItem = new WorkItemImpl();
    workItem.setName("DBFetch");
    workItem.setParameter("customerId", $order.getCustomerId());
    workItem.setParameter("sql", "SELECT discount FROM customer_discount WHERE customer_id = ?");
    
    // 异步执行工作项，处理返回结果
    kieSession.getWorkItemManager().executeWorkItem(workItem, (results) -> {
        Double discount = (Double) results.get("discount");
        if (discount != null) {
            $order.setDiscount(discount);
            update($order);
        }
    });
end

这个方案适合把DB操作做成标准化的组件，在复杂流程规则里复用性很高。

• 连接池是刚需：绝对不要用原生DriverManager每次新建连接，一定要用HikariCP这种高性能连接池，否则并发上来数据库直接崩。
• 事务要管好：如果规则里的DB操作需要和业务事务一致，在Spring环境下给业务方法加@Transactional就能保证原子性。
• 性能优化：规则里频繁查DB会拖慢性能，能提前把数据加载到工作内存就提前加载，常用数据可以加缓存（比如Redis）。
• 异常处理要到位：规则里的DB操作一定要捕获异常，别让异常直接抛出搞挂规则引擎，最好记录详细日志，方便排查。

内容的提问来源于stack exchange，提问作者ankitom