使用Java8的可选返回的JPA的最佳实践？

Question

I love Java8's semantics. I use a lot of such code in my DAOs :

  public Optional<User> findBy(String username) {
    try {
      return Optional.of(
        emp.get().createQuery("select u from User u where u.username = :username" , User.class)
        .setParameter("username" , username)
        .setMaxResults(1)
        .getSingleResult()
      );
    } catch (NoResultException e) {
      return Optional.empty();
    }
  }

It works well , but such code (try catch NoResultException ) scatters over my DAOs. And I have to catch Exception , which somehow lowers performance .

I wonder if it the best solution ? or any better solution , without try-catch ?

If it is not possible (because NoResultException is defined in JPA) , any shortcut to 'templatize' such workflow ?

Thanks.

Answer 1

If course you can templatize it, using the magic of lambdas!

Start with an @FunctionalInterface to define the lambda's contract:

@FunctionalInterface
public interface DaoRetriever<T> {
    T retrieve() throws NoResultException;
}

This is a Single Method Interface (or SMI) that will encapsulate the behaviour of your method.

Now create a utility method to use the SMI:

public static <T> Optional<T> findOrEmpty(final DaoRetriever<T> retriever) {
    try {
        return Optional.of(retriever.retrieve());
    } catch (NoResultException ex) {
        //log
    }
    return Optional.empty();
}

Now, using an import static in your calling code, your method above becomes:

public Optional<User> findBy(String username) {
    return findOrEmpty(() ->
            emp.get().createQuery("select u from User u where u.username = :username", User.class)
                    .setParameter("username", username)
                    .setMaxResults(1)
                    .getSingleResult());
}

So here, () -> emp.get()... is a lambda that captures the retrieval behaviour. The interface DaoRetriever is allowed to throw a NoResultException so the lambda is too.

Alternatively, I would use the other method of TypedQuery - getResultList - and change the code as follows:

public Optional<User> findBy(String username) {
    return emp.get().createQuery("select u from User u where u.username = :username", User.class)
            .setParameter("username", username)
            .setMaxResults(1)
            .getResultList()
            .stream()
            .findFirst();
}

This has the advantage of being simpler, but the disadvantage of simply discarding other results if there are any.

Answer 2

Boris is on the right track, but it can be done better. We need some more abstraction. This conversion has nothing to do with daos.

We need a family or functional interfaces of different arities that convert lambdas that throw exceptions to those that don't. FunctionalJava ( http://www.functionaljava.org/ ) does this:

So we have a family of Try classes: Try0, Try1, etc.

public interface Try0<A, Z extends Exception> {
    A f() throws Z;
}

and we want to convert that to a function that does not throw an exception:

static public <A, E extends Exception> Supplier<Validation<E, B>> toSupplierValidation(final Try0<A, E> t) {
    return () -> {
        try {
            return Validation.success(t.f());
        } catch (Exception e) {
            return Validation.fail((E) e);
        }
    };
}

Note that Validation is either an exception in the failure case or the regular value if it succeeds ( https://functionaljava.ci.cloudbees.com/job/master/javadoc/ ). If you don't care about the exception you can transform the failure case to the empty optional and the success case to have the value in the optional. This method looks like Boris's, but without the dao references (which are irrelevant):

static public <A, E extends Exception> Supplier<Optional<A>> toSupplierOptional(final Try0<A, E> t) {
    return () -> {
        try {
            return Optional.of(t.f());
        } catch (Exception e) {
            return Optional.empty();
        }
    };
}