构建基于Map的Sort对象：一种工厂方法模式下的解决方案

import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;

// 假设 WorklistColumn 和 Direction 是已定义的枚举类型
enum WorklistColumn {
    NAME, AGE, DATE
}

enum Direction {
    ASCENDING, DESCENDING
}

// 模拟 Sort 类及其内部结构
class Sort {
    private List<Column> columns = new ArrayList<>();

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

    // 静态工厂方法，用于创建带有第一个排序条件的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; // 返回当前实例，支持链式调用
    }

    // 内部类 Column，用于表示单个排序字段及其方向
    private static class Column {
        String name;
        Direction direction;

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

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

        @Override
        public String toString() {
            return name + " " + direction;
        }
    }

    @Override
    public String toString() {
        return "Sort{" +
               "columns=" + columns +
               '}';
    }
}

// 模拟异常类
class NoCriteriaException extends RuntimeException {
    public NoCriteriaException() {
        super("No sorting criteria provided.");
    }
}

public class SortBuilder {

    /**
     * 根据Map构建Sort对象。
     * Map中的第一个条目用于Sort.by()初始化，后续条目用于sort.and()链式添加。
     *
     * @param columnsDirectionsMap 包含排序字段和方向的Map。
     * @return 构建好的Sort对象。
     * @throws NoCriteriaException 如果传入的Map为空。
     */
    private Sort buildSort(Map<WorklistColumn, Direction> columnsDirectionsMap) {
        if (columnsDirectionsMap.isEmpty()) {
            throw new NoCriteriaException(); // 或者返回一个默认的空Sort对象
        }

        Iterator<Map.Entry<WorklistColumn, Direction>> criterionIterator =
                columnsDirectionsMap.entrySet().iterator();

        // 处理第一个条目
        Map.Entry<WorklistColumn, Direction> firstCriterion = criterionIterator.next();
        Sort sort = Sort.by(firstCriterion.getKey().toString(), firstCriterion.getValue());

        // 处理剩余条目
        while (criterionIterator.hasNext()) {
            Map.Entry<WorklistColumn, Direction> nextCriterion = criterionIterator.next();
            sort.and(nextCriterion.getKey().toString(), nextCriterion.getValue());
        }

        return sort;
    }

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

        // 示例1: 使用LinkedHashMap保持插入顺序
        Map<WorklistColumn, Direction> map1 = new LinkedHashMap<>();
        map1.put(WorklistColumn.NAME, Direction.ASCENDING);
        map1.put(WorklistColumn.AGE, Direction.DESCENDING);
        map1.put(WorklistColumn.DATE, Direction.ASCENDING);

        Sort sort1 = builder.buildSort(map1);
        System.out.println("Sort object from LinkedHashMap: " + sort1);
        // 预期输出: Sort{columns=[NAME ASCENDING, AGE DESCENDING, DATE ASCENDING]}

        // 示例2: 使用HashMap (顺序不可预测)
        Map<WorklistColumn, Direction> map2 = new HashMap<>();
        map2.put(WorklistColumn.DATE, Direction.DESCENDING);
        map2.put(WorklistColumn.NAME, Direction.ASCENDING);
        map2.put(WorklistColumn.AGE, Direction.ASCENDING);

        Sort sort2 = builder.buildSort(map2);
        System.out.println("Sort object from HashMap (order may vary): " + sort2);
        // 实际输出顺序可能与插入顺序不同

        // 示例3: 空Map处理
        Map<WorklistColumn, Direction> emptyMap = new LinkedHashMap<>();
        try {
            builder.buildSort(emptyMap);
        } catch (NoCriteriaException e) {
            System.out.println("Caught expected exception for empty map: " + e.getMessage());
        }
    }
}