当前位置：首页 > news >正文

组合模式介绍和经典实现

news 来源：原创 2025/6/15 12:55:49

组合模式（Composite Pattern）是一种结构型设计模式，它允许你将对象组合成树形结构来表示部分-整体层次结构。通过组合模式，客户端可以一致地处理单个对象和组合对象，无需关心对象的具体类型。这使得代码更加简洁、灵活和可扩展。

组合模式的说明

角色

Component（组件）：
- 定义了树中对象的公共接口。
- 可以是抽象类或接口，声明了所有子类共有的方法。
Leaf（叶子节点）：
- 表示叶子节点，即没有子节点的对象。
- 实现了 Component 接口，但不包含子节点。
Composite（组合节点）：
- 表示组合节点，即包含子节点的对象。
- 实现了 Component 接口，并且包含和管理子节点。
Client（客户端）：
- 通过 Component 接口操作对象，无需关心对象的具体类型。

在 OAuth2 中 `grantType` 授权中的应用案例

在 OAuth2 中，grantType 表示授权类型，常见的授权类型包括 authorization_code、password、client_credentials 和 refresh_token。我们可以使用组合模式来管理这些授权类型，使得客户端可以一致地处理不同类型的授权请求。

经典实现

假设我们有一个 OAuth2 授权服务器，需要支持多种授权类型。我们可以使用组合模式来管理这些授权类型。

import java.util.ArrayList;
import java.util.List;

// Component（组件）
public interface GrantType {
    void process();
    void add(GrantType grantType); // 只有组合节点需要实现
    void remove(GrantType grantType); // 只有组合节点需要实现
    GrantType getGrantType(int index); // 只有组合节点需要实现
}

// Leaf（叶子节点）
public class AuthorizationCodeGrant implements GrantType {
    @Override
    public void process() {
        System.out.println("Processing Authorization Code Grant");
    }

    @Override
    public void add(GrantType grantType) {
        throw new UnsupportedOperationException("Not supported in AuthorizationCodeGrant");
    }

    @Override
    public void remove(GrantType grantType) {
        throw new UnsupportedOperationException("Not supported in AuthorizationCodeGrant");
    }

    @Override
    public GrantType getGrantType(int index) {
        throw new UnsupportedOperationException("Not supported in AuthorizationCodeGrant");
    }
}

public class PasswordGrant implements GrantType {
    @Override
    public void process() {
        System.out.println("Processing Password Grant");
    }

    @Override
    public void add(GrantType grantType) {
        throw new UnsupportedOperationException("Not supported in PasswordGrant");
    }

    @Override
    public void remove(GrantType grantType) {
        throw new UnsupportedOperationException("Not supported in PasswordGrant");
    }

    @Override
    public GrantType getGrantType(int index) {
        throw new UnsupportedOperationException("Not supported in PasswordGrant");
    }
}

public class ClientCredentialsGrant implements GrantType {
    @Override
    public void process() {
        System.out.println("Processing Client Credentials Grant");
    }

    @Override
    public void add(GrantType grantType) {
        throw new UnsupportedOperationException("Not supported in ClientCredentialsGrant");
    }

    @Override
    public void remove(GrantType grantType) {
        throw new UnsupportedOperationException("Not supported in ClientCredentialsGrant");
    }

    @Override
    public GrantType getGrantType(int index) {
        throw new UnsupportedOperationException("Not supported in ClientCredentialsGrant");
    }
}

public class RefreshTokenGrant implements GrantType {
    @Override
    public void process() {
        System.out.println("Processing Refresh Token Grant");
    }

    @Override
    public void add(GrantType grantType) {
        throw new UnsupportedOperationException("Not supported in RefreshTokenGrant");
    }

    @Override
    public void remove(GrantType grantType) {
        throw new UnsupportedOperationException("Not supported in RefreshTokenGrant");
    }

    @Override
    public GrantType getGrantType(int index) {
        throw new UnsupportedOperationException("Not supported in RefreshTokenGrant");
    }
}

// Composite（组合节点）
public class CompositeGrantType implements GrantType {
    private List<GrantType> grantTypes = new ArrayList<>();

    @Override
    public void process() {
        for (GrantType grantType : grantTypes) {
            grantType.process();
        }
    }

    @Override
    public void add(GrantType grantType) {
        grantTypes.add(grantType);
    }

    @Override
    public void remove(GrantType grantType) {
        grantTypes.remove(grantType);
    }

    @Override
    public GrantType getGrantType(int index) {
        return grantTypes.get(index);
    }
}

// Client（客户端）
public class OAuth2CompositeExample {

    public static void main(String[] args) {
        // 创建授权类型对象
        GrantType authorizationCodeGrant = new AuthorizationCodeGrant();
        GrantType passwordGrant = new PasswordGrant();
        GrantType clientCredentialsGrant = new ClientCredentialsGrant();
        GrantType refreshTokenGrant = new RefreshTokenGrant();

        // 创建组合授权类型
        CompositeGrantType compositeGrantType = new CompositeGrantType();
        compositeGrantType.add(authorizationCodeGrant);
        compositeGrantType.add(passwordGrant);
        compositeGrantType.add(clientCredentialsGrant);
        compositeGrantType.add(refreshTokenGrant);

        // 处理授权请求
        compositeGrantType.process();
    }
}

运行结果

Processing Authorization Code Grant
Processing Password Grant
Processing Client Credentials Grant
Processing Refresh Token Grant

解释

Component（组件）：
- GrantType 接口定义了所有授权类型的公共方法，包括 process、add、remove 和 getGrantType。
Leaf（叶子节点）：
- AuthorizationCodeGrant、PasswordGrant、ClientCredentialsGrant 和 RefreshTokenGrant 实现了 GrantType 接口，表示具体的授权类型。对于不支持的操作，抛出 UnsupportedOperationException。
Composite（组合节点）：
- CompositeGrantType 实现了 GrantType 接口，并且包含和管理子授权类型。process 方法会递归地调用子授权类型的 process 方法。
Client（客户端）：
- 客户端代码通过 compositeGrantType 处理授权请求，而不需要关心具体授权类型的类型。这使得客户端代码更加简洁和一致。