Java中利用Map优化多层if-else排序逻辑

// 原始代码片段示例（简化）
if (itemSearch.getSort().equalsIgnoreCase("name")) {
    if (itemSearch.getSortOrder() == 1) { // ASC
        queryBuilder.append(" ORDER BY Name ASC");
    } else { // DESC
        queryBuilder.append(" ORDER BY Name DESC");
    }
} else if (itemSearch.getSort().equalsIgnoreCase("upc1")) {
    if (itemSearch.getSortOrder() == 1) { // ASC
        queryBuilder.append(" ORDER BY upc1 ASC");
    } else { // DESC
        queryBuilder.append(" ORDER BY upc1 DESC");
    }
}
// ... 更多排序字段

import java.util.Objects;

/**
 * 表示一个排序条件，作为Map的键。
 * 包含排序字段和排序方向。
 */
class ItemSearchOrder {
    private final String sort; // 排序字段
    private final int order;   // 排序方向 (1: ASC, 0: DESC)

    public ItemSearchOrder(final String sort, final int order) {
        this.sort = Objects.requireNonNull(sort, "Sort field cannot be null");
        this.order = order;
    }

    /**
     * 静态工厂方法：创建升序排序条件
     * @param sort 排序字段
     * @return ItemSearchOrder实例
     */
    public static ItemSearchOrder asc(final String sort) {
        return new ItemSearchOrder(sort, 1);
    }

    /**
     * 静态工厂方法：创建降序排序条件
     * @param sort 排序字段
     * @return ItemSearchOrder实例
     */
    public static ItemSearchOrder desc(final String sort) {
        return new ItemSearchOrder(sort, 0);
    }

    /**
     * 核心：重写equals方法，确保Map能正确比较键。
     * 两个ItemSearchOrder对象在排序字段（忽略大小写）和排序方向相同时被认为是相等的。
     */
    @Override
    public boolean equals(final Object other) {
        if (this == other) return true; // 同一对象
        if (other == null || getClass() != other.getClass()) return false; // 类型不一致或为空

        ItemSearchOrder that = (ItemSearchOrder) other;
        // 比较排序方向，并忽略大小写比较排序字段
        return this.order == that.order && this.sort.equalsIgnoreCase(that.sort);
    }

    /**
     * 核心：重写hashCode方法，与equals方法保持一致性。
     * Map在存储和查找键时会先使用hashCode，再使用equals。
     */
    @Override
    public int hashCode() {
        // 使用Objects.hash生成哈希码，确保所有相关字段都被考虑
        // 注意：这里为了与equalsIgnoreCase保持一致，可以考虑将sort字段转为小写再计算hash
        return Objects.hash(sort.toLowerCase(), order);
    }

    @Override
    public String toString() {
        return "ItemSearchOrder{" +
               "sort='" + sort + '\'' +
               ", order=" + (order == 1 ? "ASC" : "DESC") +
               '}';
    }
}

import java.util.List;
import java.util.Map;
import java.util.Objects;
// ... 其他导入

public class ItemService {

    // 使用静态 final Map 来存储排序查询字符串，确保只初始化一次
    private static final Map<ItemSearchOrder, String> SORT_QUERIES = Map.ofEntries(
        Map.entry(ItemSearchOrder.asc("name"), "ORDER BY name ASC"),
        Map.entry(ItemSearchOrder.desc("name"), "ORDER BY name DESC"),
        Map.entry(ItemSearchOrder.asc("upc1"), "ORDER BY upc1 ASC"),
        Map.entry(ItemSearchOrder.desc("upc1"), "ORDER BY upc1 DESC"),
        Map.entry(ItemSearchOrder.asc("minQuantity"), "ORDER BY minQuantity ASC"),
        Map.entry(ItemSearchOrder.desc("minQuantity"), "ORDER BY minQuantity DESC")
        // ... 更多排序选项
    );

    // 假设 ItemSearch 类包含 getSort() 和 getSortOrder() 方法
    // public class ItemSearch {
    //     private String sort;
    //     private int sortOrder; // 1 for ASC, 0 for DESC
    //     // ... getters and setters
    // }

    /**
     * 获取业务搜索项列表，并应用排序逻辑。
     *
     * @param itemSearch 包含搜索和排序条件的ItemSearch对象
     * @param queryBuilder 用于构建SQL查询的StringBuilder
     * @return 应用排序后的SQL ORDER BY子句
     */
    public String getSortClause(final ItemSearch itemSearch) {
        // 从 itemSearch 中获取排序字段和方向
        String sortField = itemSearch.getSort();
        int sortOrder = itemSearch.getSortOrder();

        // 根据获取到的信息构建 ItemSearchOrder 键
        ItemSearchOrder orderKey = new ItemSearchOrder(sortField, sortOrder);

        // 从 Map 中查找对应的排序SQL子句
        String sortClause = SORT_QUERIES.get(orderKey);

        if (sortClause == null) {
            // 如果Map中没有找到对应的排序规则，可以抛出异常、返回默认排序或日志记录
            System.err.println("Unknown or unsupported sort option: " + orderKey);
            // 示例：返回默认排序或空字符串
            return ""; // 或者 "ORDER BY id ASC" 等默认值
        }
        return sortClause;
    }

    // 假设原始的 getBussinessSearchItem 方法现在可以调用 getSortClause
    public List<Item> getBussinessSearchItem(ItemSearch itemSearch, byte searchType, int size, int offSet){
        StringBuilder queryBuilder = new StringBuilder();
        // ... 其他查询条件构建

        // 应用排序逻辑
        String sortClause = getSortClause(itemSearch);
        if (!sortClause.isEmpty()) {
            queryBuilder.append(" ").append(sortClause);
        }

        // ... 执行查询并返回结果
        return List.of(); // 示例返回
    }
}

// 假设 ItemSearch 和 Item 类已定义
class ItemSearch {
    private String origin;
    private String sort;
    private int sortOrder; // 1 for ASC, 0 for DESC

    public String getOrigin() { return origin; }
    public String getSort() { return sort; }
    public int getSortOrder() { return sortOrder; }

    // 构造函数、setter等省略
}

class Item {
    // Item 类的属性和方法省略
}