JPA getSingleResult () hoặc null

Tôi có một insertOrUpdatephương thức chèn vào Entitykhi nó không tồn tại hoặc cập nhật nó nếu có. Để kích hoạt điều này, tôi phải findByIdAndForeignKey, nếu nó trả về nullchèn nếu không thì cập nhật. Vấn đề là làm thế nào để tôi kiểm tra nếu nó tồn tại? Vì vậy, tôi đã cố gắng getSingleResult. Nhưng nó ném một ngoại lệ nếu

public Profile findByUserNameAndPropertyName(String userName, String propertyName) {
    String namedQuery = Profile.class.getSimpleName() + ".findByUserNameAndPropertyName";
    Query query = entityManager.createNamedQuery(namedQuery);
    query.setParameter("name", userName);
    query.setParameter("propName", propertyName);
    Object result = query.getSingleResult();
    if (result == null) return null;
    return (Profile) result;
}

nhưng getSingleResultném một Exception.

Cảm ơn

Ném một ngoại lệ là cách getSingleResult()chỉ ra nó không thể được tìm thấy. Cá nhân tôi không thể chịu được loại API này. Nó buộc xử lý ngoại lệ giả không có lợi ích thực sự. Bạn chỉ cần bọc mã trong một khối thử.

Ngoài ra, bạn có thể truy vấn danh sách và xem nếu nó trống. Đó không phải là một ngoại lệ. Trên thực tế vì bạn không thực hiện tra cứu khóa chính về mặt kỹ thuật nên có thể có nhiều kết quả (ngay cả khi một, cả hai hoặc kết hợp các khóa ngoại hoặc ràng buộc của bạn làm cho điều này không thể thực hiện được trong thực tế), vì vậy đây có lẽ là giải pháp phù hợp hơn.

Tôi gói gọn logic trong phương thức trợ giúp sau.

public class JpaResultHelper {
    public static Object getSingleResultOrNull(Query query){
        List results = query.getResultList();
        if (results.isEmpty()) return null;
        else if (results.size() == 1) return results.get(0);
        throw new NonUniqueResultException();
    }
}

Hãy thử điều này trong Java 8:

Optional first = query.getResultList().stream().findFirst();

Đây là một lựa chọn tốt để làm điều này:

public static <T> T getSingleResult(TypedQuery<T> query) {
    query.setMaxResults(1);
    List<T> list = query.getResultList();
    if (list == null || list.isEmpty()) {
        return null;
    }

    return list.get(0);
}

Spring có một phương thức tiện ích cho việc này:

TypedQuery<Profile> query = em.createNamedQuery(namedQuery, Profile.class);
...
return org.springframework.dao.support.DataAccessUtils.singleResult(query.getResultList());

Tôi đã hoàn thành (trong Java 8):

query.getResultList().stream().findFirst().orElse(null);

Từ JPA 2.2 , thay vì .getResultList()và kiểm tra xem danh sách có trống không hoặc tạo luồng bạn có thể trả lại luồng và lấy phần tử đầu tiên.

.getResultStream()
.findFirst()
.orElse(null);

Nếu bạn muốn sử dụng cơ chế try / Catch để xử lý vấn đề này .. thì nó có thể được sử dụng để hành động như if / other. Tôi đã sử dụng thử / bắt để thêm bản ghi mới khi tôi không tìm thấy bản ghi hiện có.

try {  //if part

    record = query.getSingleResult();   
    //use the record from the fetched result.
}
catch(NoResultException e){ //else part
    //create a new record.
    record = new Record();
    //.........
    entityManager.persist(record); 
}

Đây là phiên bản đánh máy / tổng quát, dựa trên triển khai của Rodrigo IronMan:

 public static <T> T getSingleResultOrNull(TypedQuery<T> query) {
    query.setMaxResults(1);
    List<T> list = query.getResultList();
    if (list.isEmpty()) {
        return null;
    }
    return list.get(0);
}

Có một cách khác mà tôi muốn giới thiệu:

Query query = em.createQuery("your query");
List<Element> elementList = query.getResultList();
return CollectionUtils.isEmpty(elementList ) ? null : elementList.get(0);

Điều này bảo vệ chống lại ngoại lệ con trỏ Null, đảm bảo chỉ có 1 kết quả được trả về.

Vì vậy, đừng làm điều đó!

Bạn có hai lựa chọn:

1. Chạy một lựa chọn để có được COUNT của tập kết quả của bạn và chỉ lấy dữ liệu nếu số này khác không; hoặc là

2. Sử dụng loại truy vấn khác (được đặt kết quả) và kiểm tra xem nó có 0 hoặc nhiều kết quả không. Nó nên có 1, vì vậy hãy rút nó ra khỏi bộ sưu tập kết quả của bạn và bạn đã hoàn thành.

Tôi sẽ đi với đề nghị thứ hai, đồng ý với Cletus. Nó cho hiệu suất tốt hơn (có khả năng) 2 truy vấn. Cũng ít làm việc.

Kết hợp các bit hữu ích của các câu trả lời hiện có (giới hạn số lượng kết quả, kiểm tra xem kết quả đó là duy nhất) và sử dụng tên phương thức estabilshed (Hibernate), chúng tôi nhận được:

/**
 * Return a single instance that matches the query, or null if the query returns no results.
 *
 * @param query query (required)
 * @param <T> result record type
 * @return record or null
 */
public static <T> T uniqueResult(@NotNull TypedQuery<T> query) {
    List<T> results = query.setMaxResults(2).getResultList();
    if (results.size() > 1) throw new NonUniqueResultException();
    return results.isEmpty() ? null : results.get(0);
}

Phương thức không có giấy tờ uniqueResultOptionaltrong org.hibernate.query.Query nên thực hiện thủ thuật. Thay vì phải bắt một NoResultExceptionbạn chỉ có thể gọi query.uniqueResultOptional().orElse(null).

Tôi đã giải quyết điều này bằng cách sử dụng List<?> myList = query.getResultList();và kiểm tra xem có myList.size()bằng không.

Đây là logic giống như những người khác đã đề xuất (lấy resultList, trả về phần tử duy nhất hoặc null), sử dụng Google Guava và TypedQuery.

public static <T> getSingleResultOrNull(final TypedQuery<T> query) {
    return Iterables.getOnlyElement(query.getResultList(), null); 
}

Lưu ý rằng Guava sẽ trả về IllegalArgumentException không trực quan nếu tập kết quả có nhiều hơn một kết quả. (Ngoại lệ có ý nghĩa đối với các máy khách của getOnlyEuity (), vì nó lấy danh sách kết quả làm đối số của nó, nhưng ít hiểu đối với các máy khách của getSingleResultOrNull ().)

Đây là một phần mở rộng khác, lần này là trong Scala.

customerQuery.getSingleOrNone match {
  case Some(c) => // ...
  case None    => // ...
}

Với ma cô này:

import javax.persistence.{NonUniqueResultException, TypedQuery}
import scala.collection.JavaConversions._

object Implicits {

  class RichTypedQuery[T](q: TypedQuery[T]) {

    def getSingleOrNone : Option[T] = {

      val results = q.setMaxResults(2).getResultList

      if (results.isEmpty)
        None
      else if (results.size == 1)
        Some(results.head)
      else
        throw new NonUniqueResultException()
    }
  }

  implicit def query2RichQuery[T](q: TypedQuery[T]) = new RichTypedQuery[T](q)
}

Nhìn mã này:

return query.getResultList().stream().findFirst().orElse(null);

Khi findFirst()được gọi có lẽ có thể được ném NullPulumException.

aproach tốt nhất là:

return query.getResultList().stream().filter(Objects::nonNull).findFirst().orElse(null);

Vì vậy, tất cả các giải pháp "cố gắng viết lại mà không có ngoại lệ" trong trang này có một vấn đề nhỏ. Hoặc là nó không ném ngoại lệ NonUnique, cũng không ném nó trong một số trường hợp sai (xem bên dưới).

Tôi nghĩ rằng giải pháp thích hợp là (có thể) này:

public static <L> L getSingleResultOrNull(TypedQuery<L> query) {
    List<L> results = query.getResultList();
    L foundEntity = null;
    if(!results.isEmpty()) {
        foundEntity = results.get(0);
    }
    if(results.size() > 1) {
        for(L result : results) {
            if(result != foundEntity) {
                throw new NonUniqueResultException();
            }
        }
    }
    return foundEntity;
}

Nó trả về bằng null nếu có 0 phần tử trong danh sách, trả về nonunique nếu có các phần tử khác nhau trong danh sách, nhưng không trả về nonunique khi một trong các lựa chọn của bạn không được thiết kế đúng và trả về cùng một đối tượng sau đó một lần.

Hãy bình luận.

Tôi đã đạt được điều này bằng cách lấy danh sách kết quả sau đó kiểm tra xem nó có trống không

public boolean exist(String value) {
        List<Object> options = getEntityManager().createNamedQuery("AppUsers.findByEmail").setParameter('email', value).getResultList();
        return !options.isEmpty();
    }

Thật là khó chịu getSingleResult() ném ngoại lệ

Ném:

1. NoResultException - nếu không có kết quả
2. NonUniqueResultException - nếu có nhiều hơn một kết quả và một số ngoại lệ khác mà bạn có thể nhận thêm thông tin từ tài liệu của họ

Đó là công việc với tôi:

Optional<Object> opt = Optional.ofNullable(nativeQuery.getSingleResult());
return opt.isPresent() ? opt.get() : null;