解释器模式（Interpreter Pattern）

解释器模式（Interpreter Pattern） 用于定义一个语言的文法，并建立一个解释器来"运行"这个语言中的句子。比如，你可以用它来解析简单的命令、表达式或配置规则。它的核心思想是：把每一个语法规则（比如"加法"、"变量"）都封装成一个类，然后通过组合这些对象来构建复杂的表达式，最后调用它们的 interpret() 方法一步步计算出结果。这种模式适合处理结构清晰、规则固定的简单语言，但语法复杂时会显得臃肿，因此使用场景有限。

java 复制代码

/**
 * 抽象表达式接口 - 定义解释方法
 */
public interface Expression {
    /**
     * 解释给定的上下文
     * @param context 上下文环境
     * @return 解释结果
     */
    boolean interpret(Context context);
}

java 复制代码

/**
 * 角色表达式 - 判断用户角色是否符合条件
 */
public class RoleExpression implements Expression {
    private String expectedRole;

    public RoleExpression(String role) {
        this.expectedRole = role;
    }

    @Override
    public boolean interpret(Context context) {
        String userRole = (String) context.getData("userRole");
        return expectedRole.equals(userRole);
    }
}

java 复制代码

/**
 * 权限表达式 - 判断用户权限级别是否达到要求
 */
public class PermissionExpression implements Expression {
    private int requiredLevel;

    public PermissionExpression(int level) {
        this.requiredLevel = level;
    }

    @Override
    public boolean interpret(Context context) {
        int userLevel = context.getIntData("permissionLevel");
        return userLevel >= requiredLevel;
    }
}

java 复制代码

/**
 * 与表达式 - 组合两个表达式的逻辑与运算
 */
public class AndExpression implements Expression {
    private Expression expr1;
    private Expression expr2;

    public AndExpression(Expression expr1, Expression expr2) {
        this.expr1 = expr1;
        this.expr2 = expr2;
    }

    @Override
    public boolean interpret(Context context) {
        return expr1.interpret(context) && expr2.interpret(context);
    }
}

java 复制代码

/**
 * 或表达式 - 组合两个表达式的逻辑或运算
 */
public class OrExpression implements Expression {
    private Expression expr1;
    private Expression expr2;

    public OrExpression(Expression expr1, Expression expr2) {
        this.expr1 = expr1;
        this.expr2 = expr2;
    }

    @Override
    public boolean interpret(Context context) {
        return expr1.interpret(context) || expr2.interpret(context);
    }
}

java 复制代码

/**
 * 非表达式 - 对表达式结果取反
 */
public class NotExpression implements Expression {
    private Expression expression;

    public NotExpression(Expression expression) {
        this.expression = expression;
    }

    @Override
    public boolean interpret(Context context) {
        return !expression.interpret(context);
    }
}

java 复制代码

import java.util.Map;
import java.util.HashMap;

/**
 * 上下文类 - 存储解释所需的环境信息
 */
public class Context {
    private Map<String, Object> data;

    public Context() {
        this.data = new HashMap<>();
    }

    public void setData(String key, Object value) {
        this.data.put(key, value);
    }

    public Object getData(String key) {
        return this.data.get(key);
    }

    public Boolean getBooleanData(String key) {
        Object value = this.data.get(key);
        if (value instanceof Boolean) {
            return (Boolean) value;
        }
        return Boolean.FALSE;
    }

    public Integer getIntData(String key) {
        Object value = this.data.get(key);
        if (value instanceof Integer) {
            return (Integer) value;
        }
        return 0;
    }
}

java 复制代码

/**
 * 解释器模式演示类 - 实现一个简单的权限控制系统
 */
public class InterpreterPatternDemo {
    public static void main(String[] args) {
        // 创建基础表达式
        Expression isAdmin = new RoleExpression("admin");
        Expression isManager = new RoleExpression("manager");
        Expression hasHighPermission = new PermissionExpression(5);
        Expression hasNormalPermission = new PermissionExpression(3);

        // 构建复杂的权限规则
        // 规则1: admin角色可以直接访问
        Expression rule1 = isAdmin;

        // 规则2: manager角色且权限等级>=5可以访问
        Expression rule2 = new AndExpression(isManager, hasHighPermission);

        // 规则3: 普通员工但权限等级>=3且不是黑名单用户可以访问
        Expression isRegularUser = new RoleExpression("user");
        Expression isNotBlacklisted = new NotExpression(new RoleExpression("blacklisted"));
        Expression rule3 = new AndExpression(
                new AndExpression(isRegularUser, hasNormalPermission),
                isNotBlacklisted
        );

        // 组合所有规则: 满足任一规则即可访问
        Expression accessRule = new OrExpression(
                rule1,
                new OrExpression(rule2, rule3)
        );

        // 测试不同用户场景
        System.out.println("=== 权限控制系统演示 ===\n");

        // 测试管理员
        Context adminContext = new Context();
        adminContext.setData("userRole", "admin");
        adminContext.setData("permissionLevel", 1);
        System.out.println("用户角色: admin, 权限等级: 1");
        System.out.println("访问结果: " + (accessRule.interpret(adminContext) ? "允许访问" : "拒绝访问") + "\n");

        // 测试经理
        Context managerContext = new Context();
        managerContext.setData("userRole", "manager");
        managerContext.setData("permissionLevel", 6);
        System.out.println("用户角色: manager, 权限等级: 6");
        System.out.println("访问结果: " + (accessRule.interpret(managerContext) ? "允许访问" : "拒绝访问") + "\n");

        // 测试普通员工
        Context userContext = new Context();
        userContext.setData("userRole", "user");
        userContext.setData("permissionLevel", 4);
        System.out.println("用户角色: user, 权限等级: 4");
        System.out.println("访问结果: " + (accessRule.interpret(userContext) ? "允许访问" : "拒绝访问") + "\n");

        // 测试不符合条件的用户
        Context lowUserContext = new Context();
        lowUserContext.setData("userRole", "user");
        lowUserContext.setData("permissionLevel", 2);
        System.out.println("用户角色: user, 权限等级: 2");
        System.out.println("访问结果: " + (accessRule.interpret(lowUserContext) ? "允许访问" : "拒绝访问") + "\n");

        // 测试黑名单用户
        Context blackListedContext = new Context();
        blackListedContext.setData("userRole", "blacklisted");
        blackListedContext.setData("permissionLevel", 10);
        System.out.println("用户角色: blacklisted, 权限等级: 10");
        System.out.println("访问结果: " + (accessRule.interpret(blackListedContext) ? "允许访问" : "拒绝访问") + "\n");
    }
}