构建基于Map的Sort对象：一种优雅的解决方案

public class Sort {
    private List<Column> columns = new ArrayList<>();

    private Sort() {
        // 私有构造器，强制使用静态工厂方法
    }

    public static Sort by(String column) {
        return (new Sort()).and(column);
    }

    public static Sort by(String column, Direction direction) {
        return (new Sort()).and(column, direction);
    }

    public Sort and(String name) {
        this.columns.add(new Column(name));
        return this;
    }

    public Sort and(String name, Direction direction) {
        this.columns.add(new Column(name, direction));
        return this;
    }
    // ... 其他方法
}

// 假设存在WorklistColumn枚举和Direction枚举
enum WorklistColumn {
    ID, NAME, STATUS
}

enum Direction {
    ASCENDING, DESCENDING
}

// Column类用于封装排序字段和方向
class Column {
    String name;
    Direction direction;

    public Column(String name) {
        this(name, Direction.ASCENDING); // 默认升序
    }

    public Column(String name, Direction direction) {
        this.name = name;
        this.direction = direction;
    }
}

import java.util.Iterator;
import java.util.Map;
import java.util.LinkedHashMap; // 示例中使用LinkedHashMap以保证顺序
import java.util.ArrayList;
import java.util.List;

// 假设Sort, WorklistColumn, Direction, Column类已定义如上

public class SortBuilder {

    /**
     * 根据Map构建Sort对象。
     * 第一个Map条目用于Sort.by()初始化，后续条目通过Sort.and()添加。
     *
     * @param columnsDirectionsMap 包含排序字段和方向的Map。
     * @return 构建好的Sort对象。
     * @throws IllegalArgumentException 如果Map为空。
     */
    private Sort buildSort(Map<WorklistColumn, Direction> columnsDirectionsMap) {
        if (columnsDirectionsMap == null || columnsDirectionsMap.isEmpty()) {
            // 根据业务需求，可以抛出异常、返回null或返回一个空的Sort对象
            throw new new IllegalArgumentException("排序条件Map不能为空。");
        }

        // 获取Map条目的迭代器
        Iterator<Map.Entry<WorklistColumn, Direction>> criterionIterator =
                columnsDirectionsMap.entrySet().iterator();

        // 1. 处理第一个Map条目，用于初始化Sort对象
        Map.Entry<WorklistColumn, Direction> firstCriterion = criterionIterator.next();
        Sort sort = Sort.by(firstCriterion.getKey().toString(), firstCriterion.getValue());

        // 2. 循环处理剩余的Map条目，通过and()方法追加排序条件
        while (criterionIterator.hasNext()) {
            Map.Entry<WorklistColumn, Direction> subsequentCriterion = criterionIterator.next();
            sort.and(subsequentCriterion.getKey().toString(), subsequentCriterion.getValue());
        }

        return sort;
    }

    public static void main(String[] args) {
        SortBuilder builder = new SortBuilder();

        // 使用LinkedHashMap确保排序顺序与插入顺序一致
        Map<WorklistColumn, Direction> criteriaMap = new LinkedHashMap<>();
        criteriaMap.put(WorklistColumn.NAME, Direction.ASCENDING);
        criteriaMap.put(WorklistColumn.ID, Direction.DESCENDING);
        criteriaMap.put(WorklistColumn.STATUS, Direction.ASCENDING);

        try {
            Sort finalSort = builder.buildSort(criteriaMap);
            System.out.println("构建的Sort对象包含的排序规则:");
            // 假设Sort类有一个getColumns方法用于调试
            for (Column col : finalSort.columns) {
                System.out.println("  - " + col.name + ": " + col.direction);
            }

            // 测试空Map情况
            Map<WorklistColumn, Direction> emptyMap = new LinkedHashMap<>();
            builder.buildSort(emptyMap); // 预期抛出异常
        } catch (IllegalArgumentException e) {
            System.err.println("错误: " + e.getMessage());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}