Java 权限框架解耦：使用设计模式消除代码耦合

在设计权限框架时，我们需要将权限控制的逻辑与业务逻辑分离，以达到代码解耦的目的。下面介绍几种设计模式来解决此类问题。

职责链模式

职责链模式将请求的发送者和接收者解耦，将请求沿着一个链条依次传递，直到有一个对象处理它为止。在权限框架中，我们可以将权限控制的逻辑封装成一个链条，每个节点处理一部分权限控制的逻辑，直到最终得出是否有权限。这样做可以有效地降低代码的耦合度。

以下是一个职责链模式的示例代码：

public abstract class AbstractPermissionHandler {
    private AbstractPermissionHandler nextHandler;

    public void setNextHandler(AbstractPermissionHandler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public abstract boolean handlePermission(User user, Permission permission);

    protected boolean callNextHandler(User user, Permission permission) {
        if (nextHandler == null) {
            return true;
        }
        return nextHandler.handlePermission(user, permission);
    }
}

public class PermissionHandler1 extends AbstractPermissionHandler {

    @Override
    public boolean handlePermission(User user, Permission permission) {
        // 处理权限控制逻辑
        if (user.hasPermission(permission)) {
            return callNextHandler(user, permission);
        }
        return false;
    }
}

public class PermissionHandler2 extends AbstractPermissionHandler {

    @Override
    public boolean handlePermission(User user, Permission permission) {
        // 处理权限控制逻辑
        if (user.getRole().hasPermission(permission)) {
            return callNextHandler(user, permission);
        }
        return false;
    }
}

public class PermissionHandler3 extends AbstractPermissionHandler {

    @Override
    public boolean handlePermission(User user, Permission permission) {
        // 处理权限控制逻辑
        if (permission.isPublic() || user.isAdmin()) {
            return callNextHandler(user, permission);
        }
        return false;
    }
}

public class PermissionCheck {
    private AbstractPermissionHandler firstHandler;

    public void setFirstHandler(AbstractPermissionHandler firstHandler) {
        this.firstHandler = firstHandler;
    }

    public boolean checkPermission(User user, Permission permission) {
        if (firstHandler == null) {
            return false;
        }
        return firstHandler.handlePermission(user, permission);
    }
}

在上面的代码中，我们定义了一个抽象的权限处理器 AbstractPermissionHandler，它有一个指向下一个处理器的引用 nextHandler，并且定义了一个抽象的 handlePermission 方法，用于处理权限控制逻辑。每个具体的权限处理器实现 handlePermission 方法，并在必要的情况下调用 callNextHandler 方法，将请求传递给下一个处理器。最后，我们定义了一个 PermissionCheck 类，它有一个指向第一个处理器的引用 firstHandler，并提供了一个 checkPermission 方法，用于检查用户是否有指定的权限。

策略模式

策略模式将算法的实现与算法的调用分离。在权限框架中，我们可以将不同的权限验证逻辑封装成不同的策略，并在需要的时候选择合适的策略进行验证。这样做可以使权限验证逻辑更加灵活和可扩展。

public interface PermissionStrategy {
    boolean hasPermission(User user, Permission permission);
}

public class PermissionStrategy1 implements PermissionStrategy {

    @Override
    public boolean hasPermission(User user, Permission permission) {
        // 基于用户权限的策略
        return user.hasPermission(permission);
    }
}

public class PermissionStrategy2 implements PermissionStrategy {

    @Override
    public boolean hasPermission(User user, Permission permission) {
        // 基于角色权限的策略
        return user.getRole().hasPermission(permission);
    }
}

public class PermissionStrategy3 implements PermissionStrategy {

    @Override
    public boolean hasPermission(User user, Permission permission) {
        // 基于公开权限的策略
        return permission.isPublic() || user.isAdmin();
    }
}

public class PermissionManager {
    private PermissionStrategy strategy;

    public void setStrategy(PermissionStrategy strategy) {
        this.strategy = strategy;
    }

    public boolean checkPermission(User user, Permission permission) {
        if (strategy == null) {
            return false;
        }
        return strategy.hasPermission(user, permission);
    }
}

在上面的代码中，我们定义了一个 PermissionStrategy 接口，它定义了一个 hasPermission 方法，用于判断用户是否有指定的权限。每个具体的策略实现 hasPermission 方法，并根据不同的规则进行判断。最后，我们定义了一个 PermissionManager 类，它有一个指向策略的引用 strategy，并提供了一个 checkPermission 方法，用于检查用户是否有指定的权限。

通过使用设计模式，我们可以有效地降低代码的耦合度，使权限框架更加灵活和可扩展。你可以根据实际情况选择适合的设计模式来解决代码耦合的问题。