Spring Data跨后端通用JPQL查询接口及通用数据结构问询

Great question! Unfortunately, Spring Data doesn’t offer a built-in universal interface across all its backend modules (MongoDB, Cassandra, you name it) that lets you pass a JPQL-style query and get back a List<Map<String, Object>> or nested generic structure out of the box. Each backend has its own specialized operations (like MongoOperations, CassandraOperations) tailored to their query languages and data models, and they don’t share a common parent interface for this kind of dynamic, schema-agnostic querying.

That said, you can build a flexible solution yourself to achieve your goal. Here’s how:

Option 1: Custom Universal Interface with Adapter Pattern #

The cleanest approach is to define your own generic query interface, then write backend-specific adapters that wrap Spring Data’s native templates. This abstracts away backend details while keeping a consistent API for your app.

First, create your universal interface:

public interface GenericQueryExecutor {
    List<Map<String, Object>> executeQuery(String query);
    // Add overloads for parameters, pagination, or projection if needed
}

MongoDB Adapter Example

Use MongoTemplate to execute MongoDB query strings and convert results to nested maps:

@Component
@Profile("mongodb")
public class MongoQueryExecutor implements GenericQueryExecutor {
    private final MongoTemplate mongoTemplate;

    public MongoQueryExecutor(MongoTemplate mongoTemplate) {
        this.mongoTemplate = mongoTemplate;
    }

    @Override
    public List<Map<String, Object>> executeQuery(String query) {
        // Execute the raw MongoDB query string
        BasicQuery basicQuery = new BasicQuery(query);
        // Convert MongoDB Documents to nested Maps (preserves arrays/embedded docs)
        return mongoTemplate.find(basicQuery, Document.class)
                .stream()
                .map(Document::toMap)
                .collect(Collectors.toList());
    }
}

Cassandra Adapter Example

Wrap CassandraTemplate to handle CQL queries, with custom logic to convert nested UDTs/collections to maps:

@Component
@Profile("cassandra")
public class CassandraQueryExecutor implements GenericQueryExecutor {
    private final CassandraTemplate cassandraTemplate;

    public CassandraQueryExecutor(CassandraTemplate cassandraTemplate) {
        this.cassandraTemplate = cassandraTemplate;
    }

    @Override
    public List<Map<String, Object>> executeQuery(String cql) {
        return cassandraTemplate.query(cql, customRowMapper());
    }

    // Custom mapper to handle nested data (UDTs, lists, maps)
    private RowMapper<Map<String, Object>> customRowMapper() {
        return (row, rowNum) -> {
            Map<String, Object> result = new HashMap<>();
            for (ColumnDefinitions.Definition def : row.getColumnDefinitions()) {
                String colName = def.getName();
                Object value = row.getObject(colName);
                // Convert UDT values to nested maps
                if (value instanceof UDTValue) {
                    result.put(colName, convertUDTToMap((UDTValue) value));
                } else {
                    result.put(colName, value);
                }
            }
            return result;
        };
    }

    private Map<String, Object> convertUDTToMap(UDTValue udtValue) {
        Map<String, Object> udtMap = new HashMap<>();
        for (String field : udtValue.getType().getFieldNames()) {
            udtMap.put(field, udtValue.getObject(field));
        }
        return udtMap;
    }
}

Use Spring profiles to activate the correct adapter based on your active backend, or build a factory bean to resolve the right executor at runtime.

Option 2: Add a Query Language Translation Layer #

If you want to use a single unified query syntax (instead of backend-specific queries like MongoDB JSON or CQL), you’ll need to:

1. Define your own simple domain-specific query language (DSL)
2. Write a translator that converts your DSL to the target backend’s native query syntax
3. Plug this translator into your GenericQueryExecutor adapters

This adds complexity but lets your app avoid coupling to backend-specific query languages.

Key Notes for Nested Data Support #

• MongoDB’s Document natively preserves nested structures, so converting to Map<String, Object> works out of the box for embedded docs and arrays.
• For Cassandra, you’ll need custom mapping logic (like the RowMapper above) to convert UDTs, lists, or sets into nested map structures.
• Other NoSQL backends (like Redis) will require similar custom result conversion logic based on their data models.

Caveats to Consider #

• Performance: Dynamic queries won’t have the same optimization as pre-defined Spring Data Repository methods, which can leverage caching and query plan reuse.
• Schema Awareness: Even without pre-defined entities, you’ll still need to understand the target backend’s data model to write valid queries.
• Transactions: Handling transactions across different backends will require extra work, as each has unique transaction semantics.

内容的提问来源于stack exchange，提问作者Paul Jackson