JPA：如何对实体中的 Set 字段进行排序？

Question

我正在使用 Spring 3.2.11.RELEASE、Hibernate 4.3.6.Final 和 JPA 2.1。我有以下具有以下字段的实体......

@Entity
@Table(name = "user")
public class User implements Serializable, Comparable<User>
{
    …
    @ManyToMany
    @JoinTable(name = "user_organization", joinColumns = { @JoinColumn(name = "USER_ID") }, inverseJoinColumns = { @JoinColumn(name = "ORGANIZATION_ID") })
    @LazyCollection(LazyCollectionOption.FALSE)
    @SortNatural
    private SortedSet<Organization> organizations;

在上面，组织的排序是通过组织的名称字段完成的。当我运行 JPA 查询来检索用户对象时，我想根据与其关联的组织的有序列表进行排序。这个我试过了……

final CriteriaBuilder builder = m_entityManager.getCriteriaBuilder();
final CriteriaQuery<User> criteria = builder.createQuery(User.class);
…
final SetJoin<User, Organization> orgsJoin = orderByRoot.join(User_.organizations, JoinType.LEFT);
orderByExpr = orgsJoin.get(Organization_.name);
criteria.orderBy(builder.asc(orderByExpr);

但它不适用于用户与多个组织相关联的情况 - 有时，在其列表中具有按字母顺序排列较低组织的用户会在正确用户之前返回。如果不写一大堆原生 SQL，我怎么能用 JPA/CriteriaBuilder 解决这个问题？

编辑：这是我想要的一个例子。我正在寻找不同的用户。

• 用户 A 有组织，“AAA 大楼”和“ZZZ 大楼”
  
• 用户 B 的组织只有“MMM 大楼”
  
• 用户 C 拥有组织“CCC 大楼”和“VVV 大楼”
• 用户 D 拥有组织“AAA Building”和“MMM Buidling”

我想要用户 D、用户 A、用户 C 和用户 B，因为用户 A 的组织的串联按字母顺序低于用户 C 的组织的串联，而用户 C 的组织按字母顺序低于用户 B 的组织。

Answer 1

您不能为实体编写这样的查询。如果您使用的是本机 SQL，您可以按 user.id 对组织名称进行 GROUP BY，但这不是您想要的。

您可以简单地获取加入用户和组织：

final CriteriaBuilder builder = m_entityManager.getCriteriaBuilder();
final CriteriaQuery<User> criteria = builder.createQuery(User.class);
Root<User> root = criteria.from(User.class);
Fetch<User, Organization> organizations = root.fetch("organizations");
criteria.select(c);
TypedQuery<User> query = em.createQuery(criteria);
List<User> users = query.getResultList();

并在内存中对它们进行排序：

Collections.sort(users, new Comparator<User>() {
    @Override
    public int compare(User user1, User user2) {
        SortedSet<Organization> organizations1 = user1.getOrganizations();
        SortedSet<Organization> organizations2 = user2.getOrganizations();

        if(organizations1.isEmpty()) {
            if(organizations2.isEmpty()) {
                return 0;
            } else {
                return -1;
            }
        } else {
            if(organizations2.isEmpty()) {
                return 1;
            } else {
                Organization o1 = organizations1.first();
                Organization o2 = organizations2.first();
                return o1.compareTo(o2);
            }
        }
    }
});

更新

如果您不想获取内存中的所有内容进行排序，那么我认为仅使用 JPQL 或 Criteria API 是不可能的。

假设组织名称是 VARCHAR(50)，我们需要先使用右填充，然后我们需要先运行 group_concat 原生查询：

PostgrSql

SELECT o.user_id, 
       string_agg(RPAD(o.name, 50) ORDER BY o.name) as ordr
FROM Organization o
GROUP BY o.user_id
order by ordr   

MySQL

SELECT o.user_id, 
       group_concat(RPAD(o.name, 50) ORDER BY o.name) as ordr
FROM Organization o
GROUP BY o.user_id
order by ordr

对 user_id 进行排序后，您可以简单地将 user_ids 提取到 List<Long>，然后运行第二个 JPQL 查询来获取用户：

List<Long> userIds = ...;

TypedQuery<User> q = em.createQuery(
    "select u " +
    "from User u " +
    "where u.id in :userIds "
, User.class);

q.setParameter("userIds", userIds);
List<User> users = q.getResultList();

Answer 2

您必须在获取用户列表后对其进行排序。在执行此操作之前，您必须对 User 类添加一些更改：

public class User implements Serializable, Comparable<User>, Comparator<User>
{
    ...

    public int compareTo(User u) {
        return compare(this, u);
    }

    public int compare(User u1, User u2) {
        Iterator<Organization> it1 = u1.organizations.iterator();
        Iterator<Organization> it2 = u2.organizations.iterator();
        while (it1.hasNext() && it2.hasNext()) {
            Organization o1 = it1.next();
            Organization o2 = it2.next();
            if(o1.compareTo(o2) != 0) {
                return o1.compareTo(o2);
            }
        }
        if(it1.hasNext())
            return 1;
        if(it2.hasNext())
            return -1;  
        return 0;
    }
}

到Organization类：

public class Organization implements Comparable<Organization>
{
    ...

    public int compareTo(Organization o) {
        return (this.name).compareTo(o.name);
    }
}

然后您可以调用以下代码获得排序的用户列表：

final CriteriaBuilder builder = m_entityManager.getCriteriaBuilder();
final CriteriaQuery<User> criteria = builder.createQuery(User.class);
Root<User> root = criteria.from(User.class);
Join<User, Organization> organizations = root.fetch("organizations");
criteria.select(root);
TypedQuery<User> query = em.createQuery(criteria);
List<User> users = query.getResultList();
Collections.sort(users, new User());

以上代码将按第一个组织的名称对用户进行排序。但如果这些名称相同，则将比较第二个组织的名称，依此类推。

编辑：

1. 我不得不承认，我的上述解决方案对于大量 用户。

2. 有两个答案建议使用string_agg(o.name, ',') 或类似函数进行SQL 查询。这些查询并不总是正确排序。让我们看下面的例子：

   • User1：只有组织“AAA”
   • User2：只有组织“AAAA”
   • User3：拥有组织“AAA”和“BBB”
   • User4：拥有组织“AAAA”和“BBB”

使用string_agg(o.name, ',')排序后，我们将收到以下订单：

• 用户 1“AAA”
• 用户2“AAAA”
• 用户4“AAAA,BBB”
• 用户3“AAA,BBB”

这是不正确的。

那么让我为您提供另一个解决方案：

将organizationNames 字段添加到User 类。在此字段中，您将存储字符串，该字符串是组织的排序名称的串联。
在连接之前，每个名称都应使用空格扩展至最大大小。
您的四个模范用户将如下所示：

• 用户AorganizationNames = "AAA Building ZZZ Building "
• 用户BorganizationNames = "MMM Building "
• 用户CorganizationNames = "CCC Building VVV Buidling "
• 用户DorganizationNames = "AAA Building MMM Buidling "

所以这会增加一些冗余。此字段的值应在更改用户的组织列表后更新。
然后您可以简单地按organizationNames 字段对用户进行排序。您可以在该列上添加索引，这样的排序应该很快。它不需要任何连接或子查询。

Answer 3

如果您想选择不同的用户，那么您无法使用您拥有的代码来执行此操作，因为不清楚按哪个组织进行排序：按第一个、第二个、...还是按最后一个。

但是有一个可行的解决方案（假设您希望始终按第一个组织进行排序）：

1. 添加新属性private String organisationsAsString; 每次更改User 时，都会将此属性设置为集合中Organisation 的串联列表。
2. 然后您只需调整您的 CriteriaQuery 以改为按新属性排序。

当然，您可以在获取Users 之后对其进行排序，但这可能有一个很大的缺点：如果您（将）有几万个，您将需要对它们进行分页。然后，按其他字段排序会复杂得多。同时加载许多用户，以及他们的关系可能是一个很大的性能瓶颈。如果您只有几百个用户，这个解决方案肯定会奏效。