如何结合ViewModel与LiveData高效频繁查询Room数据库

我来帮你逐一解决这些Room使用中的问题：

一、Room对应SQLite Cursor查询的实现方式 #

在SQLite里你需要手动创建Cursor并处理数据映射，但Room帮你省去了这些繁琐步骤——通过**@Query注解**定义SQL语句，Room会自动将查询结果映射成实体类对象的列表（或LiveData包装的列表），完全不需要手动操作Cursor。

比如你原来的SQLite查询：

Cursor cursor = db.query(TABLE_NAME, columns, searchClause, selectionArgs, null, null, null);

对应的Room Dao写法可以是这样（假设你的实体类是Shoe）：

@Dao
public interface ShoeDao {
    // 按颜色查询示例
    @Query("SELECT * FROM shoe_table WHERE colour IN (:colours)")
    LiveData<List<Shoe>> getShoesByColours(String[] colours);

    // 指定返回列的查询
    @Query("SELECT colour, selling_price FROM shoe_table WHERE size = :size")
    LiveData<List<ShoePriceBySize>> getShoePricesBySize(int size);
}

Room会自动处理数据映射、Cursor的创建与关闭，你只需要关心SQL逻辑和返回的实体类。

二、按颜色合并列表并计算平均售价的实现 #

这个需求有两种高效实现方式，优先推荐数据库层面处理：

1. 用SQL GROUP BY直接生成结果（最推荐） #

让数据库帮你完成分组和聚合计算，比内存中处理效率高得多，尤其是数据量大的时候。

首先创建一个用于接收聚合结果的POJO类：

public class ColourAveragePrice {
    private String colour;
    private double avgPrice;

    // 构造函数需与查询结果列名匹配（或用@ColumnInfo注解映射）
    public ColourAveragePrice(String colour, double avgPrice) {
        this.colour = colour;
        this.avgPrice = avgPrice;
    }

    // Getter方法
    public String getColour() { return colour; }
    public double getAvgPrice() { return avgPrice; }
}

然后在Dao中定义查询：

@Dao
public interface ShoeDao {
    // 查询所有颜色的平均售价
    @Query("SELECT colour, AVG(selling_price) AS avgPrice FROM shoe_table GROUP BY colour")
    LiveData<List<ColourAveragePrice>> getAllColourAveragePrices();

    // 过滤特定颜色的平均售价
    @Query("SELECT colour, AVG(selling_price) AS avgPrice FROM shoe_table WHERE colour IN (:colours) GROUP BY colour")
    LiveData<List<ColourAveragePrice>> getFilteredColourAveragePrices(String[] colours);
}

这样查询返回的直接就是按颜色分组好的结果，每个条目包含颜色和对应的平均售价，直接用来填充列表即可。

2. 内存中处理（适合小数据量） #

如果已经获取了全量数据，可以用Java Stream来分组计算：

// 假设你已经有了List<Shoe> allShoes
Map<String, Double> colourAvgMap = allShoes.stream()
    .collect(Collectors.groupingBy(
        Shoe::getColour,
        Collectors.averagingDouble(Shoe::getSellingPrice)
    ));

// 转换为列表用于展示
List<ColourAveragePrice> resultList = new ArrayList<>();
for (Map.Entry<String, Double> entry : colourAvgMap.entrySet()) {
    resultList.add(new ColourAveragePrice(entry.getKey(), entry.getValue()));
}

三、多查询场景下的ViewModel/Factory优化 #

你完全不需要为每个查询创建单独的ViewModel和Factory！这里推荐用Repository模式来统一管理所有数据操作，让ViewModel变得更通用：

1. 引入Repository层封装数据操作 #

把所有Dao的查询逻辑都放到Repository里，ViewModel只负责和UI层交互，调用Repository的方法获取数据：

public class ShoeRepository {
    private final ShoeDao shoeDao;

    public ShoeRepository(ShoeDao shoeDao) {
        this.shoeDao = shoeDao;
    }

    // 颜色相关查询
    public LiveData<List<ColourAveragePrice>> getColourAveragePrices(String[] colours) {
        return colours == null || colours.length == 0 
            ? shoeDao.getAllColourAveragePrices() 
            : shoeDao.getFilteredColourAveragePrices(colours);
    }

    // 鞋码相关查询
    public LiveData<List<SizeAveragePrice>> getSizeAveragePrices(int[] sizes) {
        return shoeDao.getFilteredSizeAveragePrices(sizes);
    }

    // 按颜色查最受欢迎鞋码
    public LiveData<List<PopularSizeByColour>> getPopularSizesByColour(String[] colours) {
        return shoeDao.getPopularSizesByColour(colours);
    }

    // 获取全量数据（仅在必要时使用）
    public LiveData<List<Shoe>> getAllShoes() {
        return shoeDao.getAllShoes();
    }
}

2. 创建通用的ViewModel #

这个ViewModel只持有Repository的引用，对外暴露获取不同数据的方法，参数由UI层传入：

public class ShoeViewModel extends ViewModel {
    private final ShoeRepository repository;

    public ShoeViewModel(ShoeRepository repository) {
        this.repository = repository;
    }

    // 对外提供的查询方法，按需调用
    public LiveData<List<ColourAveragePrice>> getColourAveragePrices(String[] colours) {
        return repository.getColourAveragePrices(colours);
    }

    public LiveData<List<SizeAveragePrice>> getSizeAveragePrices(int[] sizes) {
        return repository.getSizeAveragePrices(sizes);
    }

    public LiveData<List<PopularSizeByColour>> getPopularSizesByColour(String[] colours) {
        return repository.getPopularSizesByColour(colours);
    }
}

3. 简化ViewModel Factory #

只需要一个Factory来传入Repository，不需要为每个查询单独创建：

public class ShoeViewModelFactory implements ViewModelProvider.Factory {
    private final ShoeRepository repository;

    public ShoeViewModelFactory(ShoeRepository repository) {
        this.repository = repository;
    }

    @NonNull
    @Override
    public <T extends ViewModel> T create(@NonNull Class<T> modelClass) {
        if (modelClass.isAssignableFrom(ShoeViewModel.class)) {
            return (T) new ShoeViewModel(repository);
        }
        throw new IllegalArgumentException("Unknown ViewModel class");
    }
}

4. 在UI层使用 #

在Fragment/Activity中，只需要初始化一次ViewModel，然后根据需求调用不同的方法传入参数即可：

// 在Fragment的onViewCreated方法中
ShoeRepository repository = new ShoeRepository(appDatabase.shoeDao());
ShoeViewModelFactory factory = new ShoeViewModelFactory(repository);
ShoeViewModel viewModel = new ViewModelProvider(this, factory).get(ShoeViewModel.class);

// 查询蓝色的平均售价
viewModel.getColourAveragePrices(new String[]{"蓝色"}).observe(getViewLifecycleOwner(), prices -> {
    // 更新对应的ListView/RecyclerView
});

// 查询黑色+黄色的平均售价
viewModel.getColourAveragePrices(new String[]{"黑色", "黄色"}).observe(getViewLifecycleOwner(), prices -> {
    // 更新另一个列表
});

// 查询鞋码38-40的平均售价
viewModel.getSizeAveragePrices(new int[]{38, 39, 40}).observe(getViewLifecycleOwner(), sizes -> {
    // 更新第三个列表
});

这样不管你有多少种查询，都只需要这一个ViewModel和Factory，完全不用重复创建。

四、关于全量数据查询的建议 #

你的替代思路是一次性加载所有数据再过滤，这个方案只适合数据量极小的场景。如果数据库有大量数据（比如上千条），全量加载会占用大量内存，而且过滤效率远不如数据库的SQL查询。

数据库在查询优化上做了很多工作（比如索引、查询计划），尽量让数据库来处理过滤、分组、排序等逻辑，这样性能更好。

内容的提问来源于stack exchange，提问作者Peter B