使用 Spring Data JPA 時，經常會看到 findById、getOne、findOne 三個方法，新手容易迷糊，

從字面上理解，他們都是根據 ID ，或根據指定的查詢條件獲取單個物體物件，但他們的底層獲取機制、回傳值型別、以及拋例外的機制是不一樣的，因此對應的使用場景也不一樣，

1、findById 方法

findById 方法會立即（EAGER）訪問資料庫，并回傳和指定 ID 關聯的物體物件；如果沒有找到，則回傳 Optional.empty()，

定義如下：

public interface CrudRepository<T, ID> extends Repository<T, ID> {	
	/**
	 * Retrieves an entity by its id.
	 *
	 * @param id must not be {@literal null}.
	 * @return the entity with the given id or {@literal Optional#empty()} if none found.
	 * @throws IllegalArgumentException if {@literal id} is {@literal null}.
	 */
	Optional<T> findById(ID id);
}

2、getOne 方法

getOne 是一個延遲加載方法，它并不是立即訪問資料庫，而是回傳一個代理（proxy）物件，這個代理物件是對物體物件的參考，僅在 使用代理物件訪問物件屬性時才會去真正訪問資料庫 ；如果找不到，則拋出 EntityNotFoundException，

定義如下：

public interface JpaRepository<T, ID> extends PagingAndSortingRepository<T, ID>, QueryByExampleExecutor<T> {
	/**
	 * Returns a reference to the entity with the given identifier. Depending on how the JPA persistence provider is
	 * implemented this is very likely to always return an instance and throw an
	 * {@link javax.persistence.EntityNotFoundException} on first access. Some of them will reject invalid identifiers
	 * immediately.
	 *
	 * @param id must not be {@literal null}.
	 * @return a reference to the entity with the given identifier.
	 * @see EntityManager#getReference(Class, Object) for details on when an exception is thrown.
	 */
	T getOne(ID id);
}

3、findOne 方法

除了 findById、getOne 外，Spring Data JPA 還提供了兩個 findOne 方法：

• Optional<T> findOne(@Nullable Specification<T> spec)
• <S extends T> Optional<S> findOne(Example<S> example)

這兩個方法用于需要動態構建多條件查詢的場景中，它們都是立即訪問資料庫的，

定義如下：

public interface QueryByExampleExecutor<T> {
/**
	 * Returns a single entity matching the given {@link Example} or {@literal null} if none was found.
	 *
	 * @param example must not be {@literal null}.
	 * @return a single entity matching the given {@link Example} or {@link Optional#empty()} if none was found.
	 * @throws org.springframework.dao.IncorrectResultSizeDataAccessException if the Example yields more than one result.
	 */
	<S extends T> Optional<S> findOne(Example<S> example);
}

public interface JpaSpecificationExecutor<T> {
/**
	 * Returns a single entity matching the given {@link Specification} or {@link Optional#empty()} if none found.
	 *
	 * @param spec can be {@literal null}.
	 * @return never {@literal null}.
	 * @throws org.springframework.dao.IncorrectResultSizeDataAccessException if more than one entity found.
	 */
	Optional<T> findOne(@Nullable Specification<T> spec);
}

回傳型別為 Optional ，如果沒有檢索到，回傳 Optional.empty()，結果滿足條件的記錄條數超過一條，則拋出 IncorrectResultSizeDataAccessException

4、如何選擇

從上面的描述可以看出：它們主要的區別在于 加載時期 及 是否支持動態構建查詢條件 的不同，

4.1、多條件查詢的場景中，可使用 findOne

例如，根據 openId 以及 state 查詢指定的用戶：

Optional<User> user =
        postRepository.findOne(
            (root, query, cb) ->
                cb.and(cb.equal(root.get("openId"), "aaa"), cb.equal(root.get("state"), 1)));

或者使用 findOne(Example<S> example)：

User u = new User();
u.setOpenId("xxx");
u.setState(1);
Example<User> example = Example.of(u);
Optional<User> user = postRepository.findOne(example);

以上兩種寫法是等效的，執行的 SQL 如下：

Hibernate: select user0_.id as id1_0_, user0_.created_at as created_2_0_, user0_.open_id as open_id3_0_, user0_.state as state4_0_ from t_users user0_ where user0_.open_id=? and user0_.state=1

4.2、按 ID 檢索的場景中，使用 findById 或 getOne

前面已經描述過，findById 和 getOne 的最大的區別是加載時期的不同，

因此：

1、在需要延遲加載時，選擇 getOne

2、不需要延遲加載時，選擇 findById

當然了，findOne 也可以根據 ID 進行查詢，但是寫法累贅、且晦澀不易讀，不要那樣，

Optional<User> user = postRepository.findOne((root, query, cb) -> cb.equal(root.get("id"), 1));

下面，針對延遲加載的場景舉個例子：

假如有一個 Post 物件和一個 Comment 物件，Comment 物件中有一個對 Post 物件的參考，Post 和 Comment 是一對多的關系，

Post：

@Entity
@Table(name = "t_posts")
public class Post {

    @Id
    @GeneratedValue(strategy= GenerationType.AUTO)
    private Long id;

    private String title;
}

Comment：

@Entity
@Table(name = "t_comments")
public class Comment {

    @Id
    @GeneratedValue(strategy= GenerationType.AUTO)
    private Long id;

    private String content;

    @ManyToOne  
    private Post post;
}

添加一條評論，代碼如下：

public Comment addComment(long postId) {
  final Post p = postRepository.findById(postId); //（1）
  Comment c = new Comment();
  c.setContent("xxx");
  c.setPost(p);
  commentRepository.save(c);
}

上面代碼中的 (1) 處，如果使用的是 findById，則 SQL 輸出為：

select id, title from t_posts where id=? 
insert into t_comments (id, content, postId) values (?, ?, ?)

如果使用的是 getOne，則 SQL 輸出為：

insert into t_comments (id, content, postId) values (?, ?, ?)

由于新建 Comment 物件時，需要設定它關聯的 Post 物件，如果使用 findById 來獲取 Post 物件，會多觸發一次資料庫加載，而如果利用 getOne 的延遲加載策略機制，可以減少一次不必要的資料庫互動，

5、總結

1、getOne 是延遲加載；而 findById、findOne 是立即加載，

2、 getOne 如果找不到記錄會拋出EntityNotFoundException；而 findById、findOne 會回傳 Optional.empty()，

3、 在 @ManyToOne 的場景中使用 findOne ，可以獲得延遲加載機制帶來的性能優勢，

4、 在根據非 ID 查詢、或動態查詢的場景中，使用 findOne，

5、 findOne 查詢條件不能回傳超過一條，否則會拋出 IncorrectResultSizeDataAccessException，

（完）

標籤：Java

上一篇：vector專題

下一篇：JVM系列【5】JVM常用指令