还有更加复杂一点的代码示例？

当然，下面是一个稍微复杂一些的示例，演示如何使用Easy Rules来实现一个简单的银行账户系统：

import org.easyrules.annotation.Action;
import org.easyrules.annotation.Condition;
import org.easyrules.annotation.Rule;
import org.easyrules.core.BasicRule;
import org.easyrules.core.CompositeRule;
import org.easyrules.core.Rules;

public class BankAccount {

    private int balance;

    public BankAccount(int balance) {
        this.balance = balance;
    }

    public int getBalance() {
        return balance;
    }

    public void deposit(int amount) {
        balance += amount;
    }

    public void withdraw(int amount) {
        balance -= amount;
    }

    public boolean canWithdraw(int amount) {
        return balance >= amount;
    }

    public static void main(String[] args) {
        BankAccount account = new BankAccount(100);

        // 创建规则集合
        Rules rules = new Rules();

        // 创建规则
        rules.register(new MinimumBalanceRule(account));
        rules.register(new MaximumWithdrawalRule(account));
        rules.register(new WithdrawalRule(account));

        // 执行规则
        rulesEngine.fire(rules);
    }

    // 规则1：最低余额规则
    @Rule(name = "MinimumBalanceRule", description = "Check if the balance is above the minimum required")
    public static class MinimumBalanceRule extends BasicRule {

        private BankAccount account;

        public MinimumBalanceRule(BankAccount account) {
            super("MinimumBalanceRule", "Check if the balance is above the minimum required", 1);
            this.account = account;
        }

        @Condition
        public boolean isBalanceBelowMinimum() {
            return account.getBalance() < 100;
        }

        @Action
        public void notifyBalanceBelowMinimum() {
            System.out.println("Balance is below minimum!");
        }

    }

    // 规则2：最大取款规则
    @Rule(name = "MaximumWithdrawalRule", description = "Check if the withdrawal amount is below the maximum allowed")
    public static class MaximumWithdrawalRule extends BasicRule {

        private BankAccount account;

        public MaximumWithdrawalRule(BankAccount account) {
            super("MaximumWithdrawalRule", "Check if the withdrawal amount is below the maximum allowed", 2);
            this.account = account;
        }

        @Condition
        public boolean isWithdrawalAboveMaximum() {
            return account.canWithdraw(500);
        }

        @Action
        public void notifyWithdrawalAboveMaximum() {
            System.out.println("Withdrawal amount is above maximum!");
        }

    }

    // 规则3：取款规则
    @Rule(name = "WithdrawalRule", description = "Withdraw money from the account")
    public static class WithdrawalRule extends BasicRule {

        private BankAccount account;

        public WithdrawalRule(BankAccount account) {
            super("WithdrawalRule", "Withdraw money from the account", 3);
            this.account = account;
        }

        @Condition
        public boolean canWithdraw() {
            return account.canWithdraw(50);
        }

        @Action
        public void withdraw() {
            account.withdraw(50);
            System.out.println("Withdrawal successful!");
        }

    }

}

在上面的代码中，我们首先定义了一个`BankAccount`类，表示银行账户，它有一个整型变量`balance`表示账户余额，以及`deposit()`、`withdraw()`、`canWithdraw()`等方法用于存款、取款和判断是否可以取款。接下来，我们创建了三个规则：

1. `MinimumBalanceRule`规则：用于检查账户余额是否低于最低余额，如果低于最低余额，则输出警告信息。
2. `MaximumWithdrawalRule`规则：用于检查取款金额是否超过最大限额，如果超过最大限额，则输出警告信息。
3. `WithdrawalRule`规则：用于执行取款操作，如果可以取款，则执行取款操作，并输出成功信息。

最后，我们将这三个规则注册到了规则集合中，并使用规则引擎执行它们。可以看到，这个示例中使用了Easy Rules的注解方式来定义规则，同时还使用了Easy Rules的`CompositeRule`类来定义复合规则，非常方便。