// 组合模式的接口
public interface AccessDecisionVoter {
    // 投票结果的常量
    int ACCESS_GRANTED = 1;
    int ACCESS_ABSTAIN = 0;
    int ACCESS_DENIED = -1;
    // 投票方法，根据用户和请求判断是否授权
    int vote(User user, Request request);
}

// 组合模式的叶子节点，实现了AccessDecisionVoter接口
// 这个类用于判断用户是否有角色权限
public class RoleVoter implements AccessDecisionVoter {
    @Override
    public int vote(User user, Request request) {
        // 获取用户的角色列表
        List<String> roles = user.getRoles();
        // 获取请求需要的角色列表
        List<String> requiredRoles = request.getRequiredRoles();
        // 如果用户的角色列表包含请求需要的任意一个角色，则授权通过
        for (String role : requiredRoles) {
            if (roles.contains(role)) {
                return ACCESS_GRANTED;
            }
        }
        // 否则授权拒绝
        return ACCESS_DENIED;
    }
}

// 组合模式的叶子节点，实现了AccessDecisionVoter接口
// 这个类用于判断用户是否有资源权限
public class ResourceVoter implements AccessDecisionVoter {
    @Override
    public int vote(User user, Request request) {
        // 获取用户的资源列表
        List<String> resources = user.getResources();
        // 获取请求需要的资源列表
        List<String> requiredResources = request.getRequiredResources();
        // 如果用户的资源列表包含请求需要的所有资源，则授权通过
        for (String resource : requiredResources) {
            if (!resources.contains(resource)) {
                return ACCESS_DENIED;
            }
        }
        return ACCESS_GRANTED;
    }
}

// 组合模式的容器节点，实现了AccessDecisionVoter接口
// 这个类用于组合多个AccessDecisionVoter对象，并根据投票结果决定是否授权
public class AccessDecisionManager implements AccessDecisionVoter {
    // 组合多个AccessDecisionVoter对象，使用List存储
    private List<AccessDecisionVoter> voters;

    public AccessDecisionManager(List<AccessDecisionVoter> voters) {
        this.voters = voters;
    }

    @Override
    public int vote(User user, Request request) {
        // 记录投票结果的变量
        int result = ACCESS_ABSTAIN;
        // 遍历所有的AccessDecisionVoter对象，进行投票
        for (AccessDecisionVoter voter : voters) {
            int vote = voter.vote(user, request);
            // 如果有任何一个投票结果是拒绝，则直接返回拒绝
            if (vote == ACCESS_DENIED) {
                return ACCESS_DENIED;
            }
            // 如果有任何一个投票结果是通过，则记录为通过，但不返回，继续遍历其他投票者
            if (vote == ACCESS_GRANTED) {
                result = ACCESS_GRANTED;
            }
        }
        // 返回最终的投票结果
        return result;
    }
}

// 用户类，用于模拟用户信息，包括用户名、密码、角色列表和资源列表
public class User {
    private String username;
    private String password;
    private List<String> roles;
    private List<String> resources;

    public User(String username, String password, List<String> roles, List<String> resources) {
        this.username = username;
        this.password = password;
        this.roles = roles;
        this.resources = resources;
    }

    public String getUsername() {
        return username;
    }

    public String getPassword() {
        return password;
    }

    public List<String> getRoles() {
        return roles;
    }

    public List<String> getResources() {
        return resources;
    }
}

// 请求类，用于模拟请求信息，包括请求路径、请求方法、请求需要的角色列表和资源列表
public class Request {
    private String path;
    private String method;
    private List<String> requiredRoles;
    private List<String> requiredResources;

    public Request(String path, String method, List<String> requiredRoles, List<String> requiredResources) {
        this.path = path;
        this.method = method;
        this.requiredRoles = requiredRoles;
        this.requiredResources = requiredResources;
    }

    public String getPath() {
        return path;
    }

    public String getMethod() {
        return method;
    }

    public List<String> getRequiredRoles() {
        return requiredRoles;
    }

    public List<String> getRequiredResources() {
        return requiredResources;
    }
}

// 依赖注入的类，用于模拟从数据库中获取用户信息和请求信息
// 这里使用了@Component注解，让Spring容器管理这个类的实例
@Component
public class DataProvider {
    // 模拟数据库中的用户信息，使用Map存储
    private Map<String, User> users;

    // 模拟数据库中的请求信息，使用Map存储
    private Map<String, Request> requests;

    // 在构造方法中初始化数据
    public DataProvider() {
        users = new HashMap<>();
        requests = new HashMap<>();
        // 创建用户对象，并添加到Map中
        User user1 = new User("admin", "123456", Arrays.asList("admin", "user"), Arrays.asList("read", "write", "delete"));
        User user2 = new User("user1", "123456", Arrays.asList("user"), Arrays.asList("read", "write"));
        User user3 = new User("user2", "123456", Arrays.asList("user"), Arrays.asList("read"));
        users.put(user1.getUsername(), user1);
        users.put(user2.getUsername(), user2);
        users.put(user3.getUsername(), user3);
        // 创建请求对象，并添加到Map中
        Request request1 = new Request("/api/user/list", "GET", Arrays.asList("admin"), Arrays.asList("read"));
        Request request2 = new Request("/api/user/add", "POST", Arrays.asList("admin"), Arrays.asList("write"));
        Request request3 = new Request("/api/user/delete", "DELETE", Arrays.asList("admin"), Arrays.asList("delete"));
        Request request4 = new Request("/api/user/update", "PUT", Arrays.asList("user"), Arrays.asList("write"));
        requests.put(request1.getPath(), request1);
        requests.put(request2.getPath(), request2);
        requests.put(request3.getPath(), request3);
        requests.put(request4.getPath(), request4);
    }

    // 根据用户名获取用户对象
    public User getUserByUsername(String username) {
        return users.get(username);
    }

    // 根据请求路径获取请求对象
    public Request getRequestByPath(String path) {
        return requests.get(path);
    }
}

// 控制器类，用于模拟接收用户的请求，并调用AccessDecisionManager进行权限验证
// 这里使用了@RestController注解，让Spring容器管理这个类的实例，并将返回值转换为JSON格式
@RestController
public class UserController {
    // 使用@Autowired注解，让Spring容器自动注入DataProvider实例
    @Autowired
    private DataProvider dataProvider;

    // 使用@Autowired注解，让Spring容器自动注入AccessDecisionManager实例
    @Autowired
    private AccessDecisionManager accessDecisionManager;

    // 使用@RequestMapping注解，映射请求路径和方法
    @RequestMapping(value = "/api/user/list", method = RequestMethod.GET)
    public String listUsers(String username, String password) {
        // 模拟从请求中获取用户名和密码
        // 根据用户名从DataProvider中获取用户对象
        User user = dataProvider.getUserByUsername(username);
        // 如果用户不存在或密码不正确，返回错误信息
        if (user == null || !user.getPassword().equals(password)) {
            return "用户名或密码错误";
        }
        // 根据请求路径从DataProvider中获取请求对象
        Request request = dataProvider.getRequestByPath("/api/user/list");
        // 调用AccessDecisionManager的vote方法进行权限验证
        int result = accessDecisionManager.vote(user, request);
        // 如果结果是通过，则返回成功信息
        if (result == AccessDecisionVoter.ACCESS_GRANTED) {
            return "查询用户列表成功";
        }
        // 否则返回失败信息
        return "没有权限查询用户列表";
    }

    @RequestMapping(value = "/api/user/add", method = RequestMethod.POST)
    public String addUser(String username, String password) {
       // 省略与上面相同的代码

       // 根据请求路径从DataProvider中获取请求
        Request request = dataProvider.getRequestByPath("/api/user/add");
        // 调用AccessDecisionManager的vote方法进行权限验证
        int result = accessDecisionManager.vote(user, request);
        // 如果结果是通过，则返回成功信息
        if (result == AccessDecisionVoter.ACCESS_GRANTED) {
            return "添加用户成功";
        }
        // 否则返回失败信息
        return "没有权限添加用户";
    }

    @RequestMapping(value = "/api/user/delete", method = RequestMethod.DELETE)
    public String deleteUser(String username, String password) {
       // 省略与上面相同的代码

       // 根据请求路径从DataProvider中获取请求对象
        Request request = dataProvider.getRequestByPath("/api/user/delete");
        // 调用AccessDecisionManager的vote方法进行权限验证
        int result = accessDecisionManager.vote(user, request);
        // 如果结果是通过，则返回成功信息
        if (result == AccessDecisionVoter.ACCESS_GRANTED) {
            return "删除用户成功";
        }
        // 否则返回失败信息
        return "没有权限删除用户";
    }

    @RequestMapping(value = "/api/user/update", method = RequestMethod.PUT)
    public String updateUser(String username, String password) {
       // 省略与上面相同的代码

       // 根据请求路径从DataProvider中获取请求对象
        Request request = dataProvider.getRequestByPath("/api/user/update");
        // 调用AccessDecisionManager的vote方法进行权限验证
        int result = accessDecisionManager.vote(user, request);
        // 如果结果是通过，则返回成功信息
        if (result == AccessDecisionVoter.ACCESS_GRANTED) {
            return "更新用户成功";
        }
        // 否则返回失败信息
        return "没有权限更新用户";
    }
}

组合模式是一种结构型设计模式，它可以将对象组合成树形结构，表示“整体-部分”的层次关系。组合模式可以让客户端以一致的方式处理单个对象和组合对象。

在Java中，有一些知名的框架使用了组合模式，例如：

Swing框架中的JComponent类和其子类，如JPanel, JButton, JLabel等，都是组合模式的例子。JComponent是抽象构件类，JPanel是容器构件类，JButton和JLabel是叶子构件类。
Spring框架中的BeanDefinition类和其子类，如RootBeanDefinition, GenericBeanDefinition等，也是组合模式的例子。BeanDefinition是抽象构件类，RootBeanDefinition是容器构件类，GenericBeanDefinition是叶子构件类。
MyBatis框架中的SqlNode接口和其实现类，如MixedSqlNode, IfSqlNode, TextSqlNode等，也是组合模式的例子。SqlNode是抽象构件接口，MixedSqlNode是容器构件类，IfSqlNode和TextSqlNode是叶子构件类。

一个简单入门的小例子：

// 抽象构件类，表示文件或文件夹
public abstract class File {
    // 文件或文件夹的名字
    protected String name;
    // 构造方法，传入名字
    public File(String name) {
        this.name = name;
    }
    // 公共的业务方法，显示文件或文件夹的信息
    public abstract void display();
    // 添加子文件或子文件夹
    public void add(File file) {
        throw new UnsupportedOperationException();
    }
    // 删除子文件或子文件夹
    public void remove(File file) {
        throw new UnsupportedOperationException();
    }
    // 获取子文件或子文件夹
    public File getChild(int i) {
        throw new UnsupportedOperationException();
    }
}

// 叶子构件类，表示文本文件
public class TextFile extends File {
    // 构造方法，传入文本文件的名字
    public TextFile(String name) {
        super(name);
    }
    // 重写业务方法，输出文本文件的信息
    @Override
    public void display() {
        System.out.println("TextFile: " + name);
    }
}

// 叶子构件类，表示图片文件
public class ImageFile extends File {
    // 构造方法，传入图片文件的名字
    public ImageFile(String name) {
        super(name);
    }
    // 重写业务方法，输出图片文件的信息
    @Override
    public void display() {
        System.out.println("ImageFile: " + name);
    }
}

// 容器构件类，表示文件夹
public class Folder extends File {
    // 存储子文件或子文件夹的列表
    private List<File> children;
    // 构造方法，传入文件夹的名字
    public Folder(String name) {
        super(name);
        children = new ArrayList<>();
    }
    // 重写业务方法，输出文件夹的信息，并递归调用子文件或子文件夹的业务方法
    @Override
    public void display() {
        System.out.println("Folder: " + name);
        for (File child : children) {
            child.display();
        }
    }
    // 重写添加子文件或子文件夹方法，将子文件或子文件夹添加到列表中
    @Override
    public void add(File file) {
        children.add(file);
    }
    // 重写删除子文件或子文件夹方法，将子文件或子文件夹从列表中移除
    @Override
    public void remove(File file) {
        children.remove(file);
    }
    // 重写获取子文件或子文件夹方法，根据索引返回对应的子文件或子文件夹
    @Override
    public File getChild(int i) {
        return children.get(i);
    }
}

// 客户端测试类
public class Client {
    public static void main(String[] args) {
        // 创建一个根文件夹
        Folder root = new Folder("root");
        // 创建两个文本文件和一个图片文件，并添加到根文件夹中
        TextFile text1 = new TextFile("text1.txt");
        TextFile text2 = new TextFile("text2.txt");
        ImageFile image1 = new ImageFile("image1.jpg");
        root.add(text1);
        root.add(text2);
        root.add(image1);
        // 创建一个子文件夹，并添加到根文件夹中
        Folder subFolder = new Folder("subFolder");
        root.add(subFolder);
        // 创建一个文本文件和一个图片文件，并添加到子文件夹中
        TextFile text3 = new TextFile("text3.txt");
        ImageFile image2 = new ImageFile("image2.jpg");
        subFolder.add(text3);
        subFolder.add(image2);
        // 调用根文件夹的业务方法，输出整个树形结构
        root.display();
        
         /*
         * 输出结果：
         * Folder: root
         * TextFile: text1.txt
         * TextFile: text2.txt
         * ImageFile: image1.jpg
         * Folder: subFolder
         * TextFile: text3.txt
         * ImageFile: image2.jpg
         */
        
    }
}

合成模式:
1.安全模式
2.透明模式
安全模式：

透明模式