只需通过为字段提供默认值来显式声明它：

public record City(Long id, String name, Integer population) {
    public City() {
        this(0L, "", 0)
    }
}

一个重要的注解。BeanPropertyRowMapper扫描setters/getters来膨胀您的Record示例，因为Record是不可变的，没有setter，并且与Java Beans规范不兼容，您会得到并空Record。请阅读这篇SO。创建记录的唯一方法是使用构造函数。因此，您有两个选择：要么使用纯Java Bean，要么实现定制的行Map器。

它看起来最简单的方式是：

@Override
public City findById(final Long id) {
    final var sql = "SELECT * FROM cities WHERE id = ?";
    return jtm.queryForObject(
            sql,
            new Object[]{ id },
            (rs, rowNum) -> new City(
                    rs.getLong("id"),
                    rs.getString("name"),
                    rs.getInt("population")));
}

或者，您可以使用reflection：

反射API

以下公共方法将添加到java.lang.Class中：

RecordComponent[] getRecordComponents()
boolean isRecord()

方法getRecordComponents()返回一个由java.lang.refect.RecordComponent对象组成的数组，其中的java.lang.refirect.RecordComponent是一个新类。此数组的元素与记录的组件相对应，顺序与它们在记录声明中出现的顺序相同。可以从数组中的每个RecordComponent中提取其他信息，包括其名称、类型、泛型类型、注解及其访问器方法。

如果给定类被声明为记录，则方法isRecord()返回TRUE。(请比较isEnum()。)

使用这些方法和类#getConstructor(类...参数类型)和构造函数#newInstance(对象...Initargs)，您可以动态创建记录。但要记住，反思可能会带来一些开销，并影响你的表现。

我添加了一个使用反射的RecordRowMapper示例和几个tests：

package by.slesh.spring.jdbc.core;
import org.springframework.jdbc.IncorrectResultSetColumnCountException;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.support.JdbcUtils;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.RecordComponent;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.*;
public class RecordRowMapper<T> implements RowMapper<T> {
    private final Constructor<T> ctor;
    private final List<Arg> args;
    public RecordRowMapper(final Class<T> model) {
        if (!model.isRecord()) {
            throw new IllegalArgumentException(
                    model + " should be a record class");
        }
        final RecordComponent[] components = model.getRecordComponents();
        this.args = new ArrayList<>(components.length);
        final Class<?>[] argTypes = new Class[components.length];
        for (int i = 0; i < components.length; ++i) {
            final RecordComponent c = components[i];
            this.args.add(new Arg(i, c.getName(), c.getType()));
            argTypes[i] = c.getType();
        }
        try {
            this.ctor = model.getConstructor(argTypes);
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(
                    "Couldn resolve constructor for types " + Arrays.toString(argTypes));
        }
    }
    @Override
    public T mapRow(final ResultSet resultSet, final int rowNumber) throws SQLException {
        final var metaData = resultSet.getMetaData();
        final int columnCount = metaData.getColumnCount();
        if (columnCount < args.size()) {
            throw new IncorrectResultSetColumnCountException(
                    args.size(), columnCount);
        }
        try {
            return ctor.newInstance(extractCtorParams(
                    resultSet, createPropertyToColumnIndexMap(
                            metaData, columnCount)));
        } catch (InstantiationException
                | IllegalAccessException
                | InvocationTargetException e) {
            throw new RuntimeException(e);
        }
    }
    private Object[] extractCtorParams(
            final ResultSet resultSet,
            final Map<String, Integer> propertyToColumnIndexMap)
            throws SQLException {
        final var params = new Object[args.size()];
        for (final var arg : args) {
            final int columnIndex = propertyToColumnIndexMap.get(arg.name);
            params[arg.order] = JdbcUtils.getResultSetValue(
                    resultSet, columnIndex, arg.type);
        }
        return params;
    }
    private Map<String, Integer> createPropertyToColumnIndexMap(
            final ResultSetMetaData metaData,
            final int columnCount)
            throws SQLException {
        final Map<String, Integer> columnPropertyToIndexMap = new HashMap<>(columnCount);
        for (int columnIndex = 1; columnIndex <= columnCount; ++columnIndex) {
            final String propertyName = JdbcUtils.convertUnderscoreNameToPropertyName(
                    JdbcUtils.lookupColumnName(metaData, columnIndex));
            columnPropertyToIndexMap.put(propertyName, columnIndex);
        }
        return columnPropertyToIndexMap;
    }
    private static record Arg(int order, String name, Class<?>type) {
    }
}

您可以使用DataClassRowMapper。它可以很好地处理唱片。

@Override
public City findById(Long id) {
    String sql = "SELECT * FROM cities WHERE id = ?";
    return jtm.queryForObject(sql, new DataClassRowMapper<>(City.class), id);
}