JPA：如何根据 ID 以外的字段值获取实体？

Question

在JPA（Hibernate）中，当我们自动生成ID字段时，假设用户不知道这个key。因此，在获取实体时，用户会根据 ID 以外的某些字段进行查询。在这种情况下我们如何获取实体（因为不能使用em.find()）。

我知道我们可以稍后使用查询并过滤结果。但是，有没有更直接的方法（因为据我了解，这是一个非常普遍的问题）。

Answer 1

这不是你所说的“问题”。

Hibernate 具有内置的find()，但您必须构建自己的查询才能获取特定对象。我推荐使用Hibernate的Criteria：

Criteria criteria = session.createCriteria(YourClass.class);
YourObject yourObject = criteria.add(Restrictions.eq("yourField", yourFieldValue))
                             .uniqueResult();

这将在您当前的类上创建一个criteria，并添加“yourField”列等于值yourFieldValue 的限制。 uniqueResult() 告诉它带来独特的结果。如果有更多对象匹配，您应该检索一个列表。

List<YourObject> list = criteria.add(Restrictions.eq("yourField", yourFieldValue)).list();

如果您还有其他问题，请随时提出。希望这会有所帮助。

Answer 2

如果您有实体Foo 的存储库，并且需要选择具有精确字符串值boo 的所有条目（也适用于其他原始类型或实体类型）。将其放入您的存储库界面：

List<Foo> findByBoo(String boo);

如果您需要订购结果：

List<Foo> findByBooOrderById(String boo);

在reference 上查看更多信息。

Answer 3

基本上，您应该添加一个特定的唯一字段。我通常使用xxxUri 字段。

class User {

    @Id
    // automatically generated
    private Long id;

    // globally unique id
    @Column(name = "SCN", nullable = false, unique = true)
    private String scn;
}

你的业务方法会这样做。

public User findUserByScn(@NotNull final String scn) {
    CriteriaBuilder builder = manager.getCriteriaBuilder();
    CriteriaQuery<User> criteria = builder.createQuery(User.class);
    Root<User> from = criteria.from(User.class);
    criteria.select(from);
    criteria.where(builder.equal(from.get(User_.scn), scn));
    TypedQuery<User> typed = manager.createQuery(criteria);
    try {
        return typed.getSingleResult();
    } catch (final NoResultException nre) {
        return null;
    }
}

Answer 4

最佳实践是使用@NaturalId 注释。它可以用作某些情况下的业务密钥它太复杂了，因此某些字段在现实世界中用作标识符。 例如，我有以用户 ID 作为主键的用户类，电子邮件也是唯一字段。所以我们可以使用 email 作为我们的自然 id

@Entity
@Table(name="user")
public class User {
  @Id
  @Column(name="id")
  private int id;

  @NaturalId
  @Column(name="email")
  private String email;

  @Column(name="name")
  private String name;
}

要获得我们的记录，只需简单地使用 'session.byNaturalId()'

Session session = sessionFactory.getCurrentSession();
User user = session.byNaturalId(User.class)
                   .using("email","huchenhai@qq.com")
                   .load()

Answer 5

此解决方案来自《Beginning Hibernate》一书：

     Query<User> query = session.createQuery("from User u where u.scn=:scn", User.class);
     query.setParameter("scn", scn);
     User user = query.uniqueResult();    

Answer 6

像这样写一个自定义方法：

public Object findByYourField(Class entityClass, String yourFieldValue)
{
    CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
    CriteriaQuery<Object> criteriaQuery = criteriaBuilder.createQuery(entityClass);
    Root<Object> root = criteriaQuery.from(entityClass);
    criteriaQuery.select(root);

    ParameterExpression<String> params = criteriaBuilder.parameter(String.class);
    criteriaQuery.where(criteriaBuilder.equal(root.get("yourField"), params));

    TypedQuery<Object> query = entityManager.createQuery(criteriaQuery);
    query.setParameter(params, yourFieldValue);

    List<Object> queryResult = query.getResultList();

    Object returnObject = null;

    if (CollectionUtils.isNotEmpty(queryResult)) {
        returnObject = queryResult.get(0);
    }

    return returnObject;
}

Answer 7

我解决了一个类似的问题，我想通过 isbnCode 而不是你的 id（主键）来查找一本书。

@Entity
public class Book implements Serializable {
    private static final long serialVersionUID = 1L;

    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Integer id;
    private String isbnCode;

...

在存储库中，该方法的创建方式与提到的@kamalveer singh 类似。注意方法名是findBy+fieldName（在我的例子中：findByisbnCode）：

@Repository
public interface BookRepository extends JpaRepository<Book, Integer> {

    Book findByisbnCode(String isbnCode);
}

然后，在服务中实现该方法：

@Service
public class BookService {

    @Autowired
    private BookRepository repo;
    
    
    public Book findByIsbnCode(String isbnCode) {
        Book obj = repo.findByisbnCode(isbnCode);
        return obj; 
    }
}

Answer 8

编辑：刚刚意识到@Chinmoy 基本上是在做同样的事情，但我认为我可能在 ELI5 上做得更好 :)

如果您使用 Spring Data 的风格来帮助从您定义的任何类型的 Repository 中持久化/获取内容，您可以让您的 JPA 提供者通过一些巧妙的技巧为您执行此操作你的Repository 接口类。请允许我解释一下。

（作为免责声明，我刚才确实/仍在为自己解决这个问题。）

例如，如果我将 Tokens 存储在我的数据库中，我可能有一个如下所示的实体类：

@Data // << Project Lombok convenience annotation
@Entity
public class Token {
    @Id
    @Column(name = "TOKEN_ID")
    private String tokenId;

    @Column(name = "TOKEN")
    private String token;

    @Column(name = "EXPIRATION")
    private String expiration;

    @Column(name = "SCOPE")
    private String scope;
}

我可能有一个像这样定义的CrudRepository<K,V> 接口，以便免费为我提供对该存储库的简单 CRUD 操作。

@Repository
// CrudRepository<{Entity Type}, {Entity Primary Key Type}>
public interface TokenRepository extends CrudRepository<Token, String> { }

例如，当我查找其中一个令牌时，我的目的可能是检查到期时间或范围。在这两种情况下，我可能没有方便的tokenId，而只是我想要查找的token 字段本身的值。

为此，您可以巧妙地向您的TokenRepository 接口添加一个额外的方法，告诉您的JPA 提供者您传递给该方法的值不是tokenId，而是Entity 类中的另一个字段，它应该在生成将针对您的数据库运行的实际 SQL 时考虑到这一点。

@Repository
// CrudRepository<{Entity Type}, {Entity Primary Key Type}>
public interface TokenRepository extends CrudRepository<Token, String> { 
    List<Token> findByToken(String token);
}

我在 Spring Data R2DBC docs page 上读到了这个，到目前为止，它似乎在存储在嵌入式 H2 数据库中的 SpringBoot 2.x 应用程序中工作。

Answer 9

不，您不需要进行标准查询，如果您在 Spring-boot 中工作，您只需做简单的事情就可以了样板代码： 在您的 repo 中使用 findBy[exact field name] 声明一个方法名称。 例子- 如果您的模型或文档包含一个字符串字段 myField 并且您想通过它查找，那么您的方法名称将是：

findBymyField(String myField);

Answer 10

所有答案都要求您编写某种 SQL/HQL/任何东西。为什么？您不必 - 只需使用 CriteriaBuilder:

Person.java：

@Entity
class Person  {
  @Id @GeneratedValue
  private int id;

  @Column(name = "name")
  private String name;
  @Column(name = "age")
  private int age;
  ...
}

Dao.java：

public class Dao  {
  public static Person getPersonByName(String name)  {
        SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();
        Session session = sessionFactory.openSession();
        session.beginTransaction();
        
        CriteriaBuilder cb = session.getCriteriaBuilder();
        
        CriteriaQuery<Person> cr = cb.createQuery(Person.class);
        Root<Person> root = cr.from(Person.class);
        cr.select(root).where(cb.equal(root.get("name"), name));  //here you pass a class field, not a table column (in this example they are called the same)

        Query query = session.createQuery(cr);
        query.setMaxResults(1);
        List<Person> resultList = query.getResultList();

        Person result = resultList.get(0);
        
        return result;
  }
}

使用示例：

public static void main(String[] args)  {
  Person person = Dao.getPersonByName("John");
  System.out.println(person.getAge());  //John's age
}

Answer 11

看看：

• JPA query language:The Java Persistence Query Language
• JPA Criteria API: Using the Criteria API to Create Queries

Answer 12

我已经编写了一个库来帮助做到这一点。它允许通过仅初始化您要过滤的字段来按对象搜索：https://github.com/kg6zvp/GenericEntityEJB

Answer 13

参考 - Spring docs for query methods

我们可以在 Spring Jpa 中通过传递 diff 参数来添加方法，例如：
List<Person> findByEmailAddressAndLastname(EmailAddress emailAddress, String lastname);

// Enabling static ORDER BY for a query 

List<Person> findByLastnameOrderByFirstnameAsc(String lastname);

Answer 14

在我的 Spring Boot 应用程序中，我解决了类似的问题，如下所示：

@Autowired
private EntityManager entityManager;

public User findByEmail(String email) {
    User user = null;
    Query query = entityManager.createQuery("SELECT u FROM User u WHERE u.email=:email");
    query.setParameter("email", email);
    try {
        user = (User) query.getSingleResult();
    } catch (Exception e) {
        // Handle exception
    }
    return user;
}

Answer 15

这是非常基本的查询：

实体：学生

@Entity
@Data
@NoArgsConstructor
public class Student{
@Id
@GeneratedValue(generator = "uuid2", strategy = GenerationType.IDENTITY)
@GenericGenerator(name = "uuid2", strategy = "uuid2")
private String id;

@Column(nullable = false)
@Version
@JsonIgnore
private Integer version;

private String studentId;

private String studentName;

private OffsetDateTime enrollDate;

}

存储库接口：StudentRepository

@Repository
public interface StudentRepository extends JpaRepository<Student, String> {

List<Student> findByStudentName(String studentName);

List<Student> findByStudentNameOrderByEnrollDateDesc(String studentName);

@Transactional
@Modifying
void deleteByStudentName(String studentName);
} 

注意： findByColumnName : 按条件给出结果

列出 findByStudentName(String studentName) 内部转换为查询：select * from Student where name='studentName'

@Transactional @修改 当您想从数据库中删除持久数据时很有用。

Answer 16

使用 CrudRepository 和 JPA 查询对我有用：

import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.CrudRepository;
import org.springframework.data.repository.query.Param;

public interface TokenCrudRepository extends CrudRepository<Token, Integer> {

 /**
 * Finds a token by using the user as a search criteria.
 * @param user
 * @return  A token element matching with the given user.
 */
    @Query("SELECT t FROM Token t WHERE LOWER(t.user) = LOWER(:user)")
    public Token find(@Param("user") String user);

}

然后你像这样调用 find 自定义方法：

public void destroyCurrentToken(String user){
    AbstractApplicationContext context = getContext();

    repository = context.getBean(TokenCrudRepository.class);

    Token token = ((TokenCrudRepository) repository).find(user);

    int idToken = token.getId();

    repository.delete(idToken);

    context.close();
}