正在获取
适用于 ✅ 开源版 ✅ 专业版 ✅ 企业版
获取数据是被 JDBC 以及各种其他数据库抽象库完全忽略的事情。获取数据不仅仅是循环或列出记录或映射对象。您可能希望从数据库中获取数据的方式有很多，它应该被视为任何数据库抽象 API 的首要特性。仅举几例，以下是 jOOQ 的一些获取模式
- 非类型化 vs. 类型化获取：有时您关心返回记录的类型，有时（对于任意投影）您不关心。
- 获取数组、映射或列表：库应该为您完成这项工作，而不是让您将结果集转换为任何更合适的数据类型。
- 通过映射器回调获取：这是一种完全不同的获取范例。借助 Java 8 的 lambda 表达式，这将变得更加强大。
- 获取自定义 POJO：这是使 Hibernate 和 JPA 如此强大的原因。自动将表映射到自定义 POJO。
- 懒加载 vs. 预加载：应该很容易区分这两种获取模式。
- 获取多个结果：某些数据库允许从单个查询返回多个结果集。 JDBC 可以处理这个问题，但非常冗长。应该返回一个结果列表。
- 异步获取数据：某些查询执行时间太长，无法等待结果。您应该能够在单独的进程中生成查询执行。
-
反应式获取数据：在反应式编程模型中，您将希望从发布者获取结果到订阅中。 jOOQ 实现了不同的
PublisherAPI。
便利性以及 ResultQuery、Result 和 Record 如何共享 API
术语“fetch”在 jOOQ 中总是被重用，当您可以从数据库中获取数据时。 org.jooq.ResultQuery 提供了许多重载的获取数据的方法
各种获取模式
这些获取模式也在手册的后续章节中进行了记录
// The "standard" fetch Result<R> fetch(); // The "standard" fetch when you know your query returns at most one record. This may return null. R fetchOne(); // The "standard" fetch when you know your query returns exactly one record. This never returns null. R fetchSingle(); // The "standard" fetch when you know your query returns at most one record. Optional<R> fetchOptional(); // The "standard" fetch when you only want to fetch the first record R fetchAny(); // Create a "lazy" Cursor, that keeps an open underlying JDBC ResultSet Cursor<R> fetchLazy(); Cursor<R> fetchLazy(int fetchSize); Stream<R> stream(); // Fetch several results at once List<Result<Record>> fetchMany(); // Fetch records into a custom callback <H extends RecordHandler<R>> H fetchInto(H handler); // Map records using a custom callback <E> List<E> fetch(RecordMapper<? super R, E> mapper); // Execute a ResultQuery with jOOQ, but return a JDBC ResultSet, not a jOOQ object ResultSet fetchResultSet();
获取便利
这些获取方法也可以从 org.jooq.Result 和 org.jooq.Record API 中获得
// These methods are convenience for fetching only a single field,
// possibly converting results to another type
<T> List<T> fetch(Field<T> field);
<T> List<T> fetch(Field<?> field, Class<? extends T> type);
<T, U> List<U> fetch(Field<T> field, Converter<? super T, U> converter);
List<?> fetch(int fieldIndex);
<T> List<T> fetch(int fieldIndex, Class<? extends T> type);
<U> List<U> fetch(int fieldIndex, Converter<?, U> converter);
List<?> fetch(String fieldName);
<T> List<T> fetch(String fieldName, Class<? extends T> type);
<U> List<U> fetch(String fieldName, Converter<?, U> converter);
// These methods are convenience for fetching only a single field, possibly converting results to another type
// Instead of returning lists, these return arrays
<T> T[] fetchArray(Field<T> field);
<T> T[] fetchArray(Field<?> field, Class<? extends T> type);
<T, U> U[] fetchArray(Field<T> field, Converter<? super T, U> converter);
Object[] fetchArray(int fieldIndex);
<T> T[] fetchArray(int fieldIndex, Class<? extends T> type);
<U> U[] fetchArray(int fieldIndex, Converter<?, U> converter);
Object[] fetchArray(String fieldName);
<T> T[] fetchArray(String fieldName, Class<? extends T> type);
<U> U[] fetchArray(String fieldName, Converter<?, U> converter);
// These methods are convenience for fetching only a single field from a single record,
// possibly converting results to another type
<T> T fetchOne(Field<T> field);
<T> T fetchOne(Field<?> field, Class<? extends T> type);
<T, U> U fetchOne(Field<T> field, Converter<? super T, U> converter);
Object fetchOne(int fieldIndex);
<T> T fetchOne(int fieldIndex, Class<? extends T> type);
<U> U fetchOne(int fieldIndex, Converter<?, U> converter);
Object fetchOne(String fieldName);
<T> T fetchOne(String fieldName, Class<? extends T> type);
<U> U fetchOne(String fieldName, Converter<?, U> converter);
获取转换
这些获取方法也可以从 org.jooq.Result 和 org.jooq.Record API 中获得
// Transform your Records into arrays, Results into matrices
Object[][] fetchArrays();
Object[] fetchOneArray();
// Reduce your Result object into maps
<K> Map<K, R> fetchMap(Field<K> key);
<K, V> Map<K, V> fetchMap(Field<K> key, Field<V> value);
<K, E> Map<K, E> fetchMap(Field<K> key, Class<E> value);
Map<Record, R> fetchMap(Field<?>[] key);
<E> Map<Record, E> fetchMap(Field<?>[] key, Class<E> value);
// Transform your Result object into maps
List<Map<String, Object>> fetchMaps();
Map<String, Object> fetchOneMap();
// Transform your Result object into groups
<K> Map<K, Result<R>> fetchGroups(Field<K> key);
<K, V> Map<K, List<V>> fetchGroups(Field<K> key, Field<V> value);
<K, E> Map<K, List<E>> fetchGroups(Field<K> key, Class<E> value);
Map<Record, Result<R>> fetchGroups(Field<?>[] key);
<E> Map<Record, List<E>> fetchGroups(Field<?>[] key, Class<E> value);
// Transform your Records into custom POJOs
<E> List<E> fetchInto(Class<? extends E> type);
// Transform your records into another table type
<Z extends Record> Result<Z> fetchInto(Table<Z> table);
请注意，除了 fetchLazy() 方法之外，所有 fetch() 方法都会立即关闭底层 JDBC 结果集。
目录
- 4.3.1.
- Record vs. TableRecord
- 4.3.2.
- 记录 1 到记录 22
- 4.3.3.
- 数组、映射和列表
- 4.3.4.
- ResultQuery 作为 Iterable
- 4.3.5.
- RecordMapper
- 4.3.6.
- POJOs
- 4.3.7.
- RecordMapperProvider
- 4.3.8.
- Ad-hoc Converter
- 4.3.9.
- ConverterProvider
- 4.3.10.
- 懒加载
- 4.3.11.
- 使用流进行懒加载
- 4.3.12.
- 批量获取
- 4.3.13.
- 稍后获取
- 4.3.14.
- 响应式获取
- 4.3.15.
- ResultSet 获取
- 4.3.16.
- 自动数据类型转换
- 4.3.17.
- 自定义数据类型转换
- 4.3.18.
- 数据类型查找
- 4.3.19.
- 上下文转换器
| 上一节 : 下一节 |
反馈
您对此页面有任何反馈吗？ 我们很乐意听到它！