Java8 Collections.sort（有時）不對JPA返回列表進行排序

Question

Java8在我的JPA EclipseLink 2.5.2環境中一直在做奇怪的事情。我必須刪除昨天的問題https://stackoverflow.com/questions/26806183/java-8-sorting-behaviour ，因爲在這種情況下排序受到了奇怪的JPA行爲的影響 - 我通過在進行最終排序之前強制執行第一個排序步驟，找到了解決方法。

仍然在JPA Eclipselink 2.5.2的Java 8中，以下代碼在我的環境（Linux，MacOSX，均使用build 1.8.0_25-b17）中不能排序。它在JDK 1.7環境中按預期工作。

public List<Document> getDocumentsByModificationDate() { 
    List<Document> docs=this.getDocuments(); 
    LOGGER.log(Level.INFO,"sorting "+docs.size()+" by modification date"); 
    Comparator<Document> comparator=new ByModificationComparator(); 
    Collections.sort(docs,comparator); 
    return docs; 
} 

從JUnit測試中調用上述函數可以正常工作。 當在生產環境中debbuging我得到一個日誌條目：

INFORMATION: sorting 34 by modification date 

但TimSort與nRemaining < 2 return語句被擊中 - 所以沒有排序發生。由JPA提供的間接列表（見What collections does jpa return?）被認爲是空的。

static <T> void sort(T[] a, int lo, int hi, Comparator<? super T> c, 
        T[] work, int workBase, int workLen) { 
    assert c != null && a != null && lo >= 0 && lo <= hi && hi <= a.length; 

    int nRemaining = hi - lo; 
    if (nRemaining < 2) 
     return; // Arrays of size 0 and 1 are always sorted 

這種解決方法正確排序：

if (docs instanceof IndirectList) { 
     IndirectList iList = (IndirectList)docs; 
     Object sortTargetObject = iList.getDelegateObject(); 
     if (sortTargetObject instanceof List<?>) { 
      List<Document> sortTarget=(List<Document>) sortTargetObject; 
      Collections.sort(sortTarget,comparator); 
     } 
    } else { 
     Collections.sort(docs,comparator); 
    } 

問：

這是一個JPA的EclipseLink錯誤或什麼可能我一般做這件事在我自己的代碼？

請注意 - 我無法將軟件更改爲符合Java8源代碼。當前的環境是一個Java8運行時。

我很驚訝這種行爲 - 尤其令人煩惱的是，在生產環境中，測試用例運行正常時存在問題。

在https://github.com/WolfgangFahl/JPAJava8Sorting 有一個示例項目，它具有與原始問題類似的結構。

它包含一個帶有JUnit測試的http://sscce.org/示例，該測試通過調用em.clear（）來重現問題，從而分離所有對象並強制使用IndirectList。請參閱下面的JUnit案例以供參考。

隨着預先抓取：

// https://stackoverflow.com/questions/8301820/onetomany-relationship-is-not-working 
@OneToMany(cascade = CascadeType.ALL, mappedBy = "parentFolder", fetch=FetchType.EAGER) 

該股情況下工作。如果使用FetchType.LAZY或在JDK 8中省略提取類型，則行爲可能與JDK 7中的不同（我現在必須檢查它）。 這是爲什麼呢？ 在這個時候，我假設你需要指定Eager抓取或迭代一次在列表上進行排序，基本上是在排序之前手動抓取。 還能做些什麼？

JUnit測試

的persistence.xml和聚甲醛。XML可以從https://github.com/WolfgangFahl/JPAJava8Sorting 測試採取可以與MySQL數據庫或內存中運行使用Derby（默認）

package com.bitplan.java8sorting; 

import static org.junit.Assert.assertEquals; 

import java.util.ArrayList; 
import java.util.Collections; 
import java.util.Comparator; 
import java.util.HashMap; 
import java.util.List; 
import java.util.Map; 
import java.util.logging.Level; 
import java.util.logging.Logger; 

import javax.persistence.Access; 
import javax.persistence.AccessType; 
import javax.persistence.CascadeType; 
import javax.persistence.Entity; 
import javax.persistence.EntityManager; 
import javax.persistence.EntityManagerFactory; 
import javax.persistence.FetchType; 
import javax.persistence.Id; 
import javax.persistence.ManyToOne; 
import javax.persistence.OneToMany; 
import javax.persistence.Persistence; 
import javax.persistence.Query; 
import javax.persistence.Table; 

import org.eclipse.persistence.indirection.IndirectList; 
import org.junit.Test; 

/** 
* Testcase for 
* https://stackoverflow.com/questions/26816650/java8-collections-sort-sometimes-does-not-sort-jpa-returned-lists 
* @author wf 
* 
*/ 
public class TestJPASorting { 

    // the number of documents we want to sort 
    public static final int NUM_DOCUMENTS = 3; 

    // Logger for debug outputs 
    protected static Logger LOGGER = Logger.getLogger("com.bitplan.java8sorting"); 

    /** 
    * a classic comparator 
    * @author wf 
    * 
    */ 
    public static class ByNameComparator implements Comparator<Document> { 

    // @Override 
    public int compare(Document d1, Document d2) { 
     LOGGER.log(Level.INFO,"comparing " + d1.getName() + "<=>" + d2.getName()); 
     return d1.getName().compareTo(d2.getName()); 
    } 
    } 

    // Document Entity - the sort target 
    @Entity(name = "Document") 
    @Table(name = "document") 
    @Access(AccessType.FIELD) 
    public static class Document { 
    @Id 
    String name; 

    @ManyToOne 
    Folder parentFolder; 

    /** 
    * @return the name 
    */ 
    public String getName() { 
     return name; 
    } 
    /** 
    * @param name the name to set 
    */ 
    public void setName(String name) { 
     this.name = name; 
    } 
    /** 
    * @return the parentFolder 
    */ 
    public Folder getParentFolder() { 
     return parentFolder; 
    } 
    /** 
    * @param parentFolder the parentFolder to set 
    */ 
    public void setParentFolder(Folder parentFolder) { 
     this.parentFolder = parentFolder; 
    } 
    } 

    // Folder entity - owning entity for documents to be sorted 
    @Entity(name = "Folder") 
    @Table(name = "folder") 
    @Access(AccessType.FIELD) 
    public static class Folder { 
    @Id 
    String name; 

    // https://stackoverflow.com/questions/8301820/onetomany-relationship-is-not-working 
    @OneToMany(cascade = CascadeType.ALL, mappedBy = "parentFolder", fetch=FetchType.EAGER) 
    List<Document> documents; 

    /** 
    * @return the name 
    */ 
    public String getName() { 
     return name; 
    } 

    /** 
    * @param name the name to set 
    */ 
    public void setName(String name) { 
     this.name = name; 
    } 

    /** 
    * @return the documents 
    */ 
    public List<Document> getDocuments() { 
     return documents; 
    } 

    /** 
    * @param documents the documents to set 
    */ 
    public void setDocuments(List<Document> documents) { 
     this.documents = documents; 
    } 

    /** 
    * get the documents of this folder by name 
    * 
    * @return a sorted list of documents 
    */ 
    public List<Document> getDocumentsByName() { 
     List<Document> docs = this.getDocuments(); 
     LOGGER.log(Level.INFO, "sorting " + docs.size() + " documents by name"); 
     if (docs instanceof IndirectList) { 
     LOGGER.log(Level.INFO, "The document list is an IndirectList"); 
     } 
     Comparator<Document> comparator = new ByNameComparator(); 
     // here is the culprit - do or don't we sort correctly here? 
     Collections.sort(docs, comparator); 
     return docs; 
    } 

    /** 
    * get a folder example (for testing) 
    * @return - a test folder with NUM_DOCUMENTS documents 
    */ 
    public static Folder getFolderExample() { 
     Folder folder = new Folder(); 
     folder.setName("testFolder"); 
     folder.setDocuments(new ArrayList<Document>()); 
     for (int i=NUM_DOCUMENTS;i>0;i--) { 
     Document document=new Document(); 
     document.setName("test"+i); 
     document.setParentFolder(folder); 
     folder.getDocuments().add(document); 
     } 
     return folder; 
    } 
    } 

    /** possible Database configurations 
    using generic persistence.xml: 
    <?xml version="1.0" encoding="UTF-8"?> 
    <!-- generic persistence.xml which only specifies a persistence unit name --> 
    <persistence xmlns="http://java.sun.com/xml/ns/persistence" 
     version="2.0"> 
     <persistence-unit name="com.bitplan.java8sorting" transaction-type="RESOURCE_LOCAL"> 
     <description>sorting test</description> 
     <provider>org.eclipse.persistence.jpa.PersistenceProvider</provider> 
     <exclude-unlisted-classes>false</exclude-unlisted-classes> 
     <properties> 
     <!-- set programmatically --> 
     </properties> 
     </persistence-unit> 
    </persistence> 
    */ 
    // in MEMORY database 
    public static final JPASettings JPA_DERBY=new JPASettings("Derby","org.apache.derby.jdbc.EmbeddedDriver","jdbc:derby:memory:test-jpa;create=true","APP","APP"); 
    // MYSQL Database 
    // needs preparation: 
    // create database testsqlstorage; 
    // grant all privileges on testsqlstorage to cm@localhost identified by 'secret'; 
    public static final JPASettings JPA_MYSQL=new JPASettings("MYSQL","com.mysql.jdbc.Driver","jdbc:mysql://localhost:3306/testsqlstorage","cm","secret"); 

    /** 
    * Wrapper class for JPASettings 
    * @author wf 
    * 
    */ 
    public static class JPASettings { 
    String driver; 
    String url; 
    String user; 
    String password; 
    String targetDatabase; 

    EntityManager entityManager; 
    /** 
    * @param driver 
    * @param url 
    * @param user 
    * @param password 
    * @param targetDatabase 
    */ 
    public JPASettings(String targetDatabase,String driver, String url, String user, String password) { 
     this.driver = driver; 
     this.url = url; 
     this.user = user; 
     this.password = password; 
     this.targetDatabase = targetDatabase; 
    } 

    /** 
    * get an entitymanager based on my settings 
    * @return the EntityManager 
    */ 
    public EntityManager getEntityManager() { 
     if (entityManager == null) { 
     Map<String, String> jpaProperties = new HashMap<String, String>(); 
     jpaProperties.put("eclipselink.ddl-generation.output-mode", "both"); 
     jpaProperties.put("eclipselink.ddl-generation", "drop-and-create-tables"); 
     jpaProperties.put("eclipselink.target-database", targetDatabase); 
     jpaProperties.put("eclipselink.logging.level", "FINE"); 

     jpaProperties.put("javax.persistence.jdbc.user", user); 
     jpaProperties.put("javax.persistence.jdbc.password", password); 
     jpaProperties.put("javax.persistence.jdbc.url",url); 
     jpaProperties.put("javax.persistence.jdbc.driver",driver); 

     EntityManagerFactory emf = Persistence.createEntityManagerFactory(
      "com.bitplan.java8sorting", jpaProperties); 
     entityManager = emf.createEntityManager(); 
     } 
     return entityManager; 
    } 
    } 

    /** 
    * persist the given Folder with the given entityManager 
    * @param em - the entityManager 
    * @param folderJpa - the folder to persist 
    */ 
    public void persist(EntityManager em, Folder folder) { 
    em.getTransaction().begin(); 
    em.persist(folder); 
    em.getTransaction().commit();  
    } 

    /** 
    * check the sorting - assert that the list has the correct size NUM_DOCUMENTS and that documents 
    * are sorted by name assuming test# to be the name of the documents 
    * @param sortedDocuments - the documents which should be sorted by name 
    */ 
    public void checkSorting(List<Document> sortedDocuments) { 
    assertEquals(NUM_DOCUMENTS,sortedDocuments.size()); 
    for (int i=1;i<=NUM_DOCUMENTS;i++) { 
     Document document=sortedDocuments.get(i-1); 
     assertEquals("test"+i,document.getName()); 
    } 
    } 

    /** 
    * this test case shows that the list of documents retrieved will not be sorted if 
    * JDK8 and lazy fetching is used 
    */ 
    @Test 
    public void testSorting() { 
    // get a folder with a few documents 
    Folder folder=Folder.getFolderExample(); 
    // get an entitymanager JPA_DERBY=inMemory JPA_MYSQL=Mysql disk database 
    EntityManager em=JPA_DERBY.getEntityManager(); 
    // persist the folder 
    persist(em,folder); 
    // sort list directly created from memory 
    checkSorting(folder.getDocumentsByName()); 

    // detach entities; 
    em.clear(); 
    // get all folders from database 
    String sql="select f from Folder f"; 
    Query query = em.createQuery(sql); 
    @SuppressWarnings("unchecked") 
    List<Folder> folders = query.getResultList(); 
    // there should be exactly one 
    assertEquals(1,folders.size()); 
    // get the first folder 
    Folder folderJPA=folders.get(0); 
    // sort the documents retrieved 
    checkSorting(folderJPA.getDocumentsByName()); 
    } 
} 

Answer 1

嗯，這是一個完美的教學遊戲，告訴你爲什麼程序員不應該擴展沒有被設計爲子類的類。像「有效的Java」這樣的書告訴你爲什麼：當超類發展時，試圖攔截每個方法來改變它的行爲將會失敗。

在這裏，IndirectList延伸Vector並重寫幾乎所有的方法來修改其行爲，一個清晰的反模式。現在，隨着Java 8的基類已經發展。

由於Java 8，接口可具有default方法等中加入等sort方法，其具有的優點是，不象Collections.sort，實現可以覆蓋的方法，並提供一種實現更適合於特定interface實現。 Vector是這樣做的，原因有兩個：現在所有方法​​的合同擴展到排序，並且優化的實現可以將其內部數組傳遞給跳過之前實現中已知的複製操作的Arrays.sort方法（ArrayList也是如此）。

即使對於現有代碼立即獲得此優惠，Collections.sort已被改裝。它委託給List.sort，默認情況下委託給另一種方法，通過toArray和TimSort執行復制的舊行爲。但是如果List執行覆蓋List.sort它也會影響Collections.sort的行爲。

    interface method    using internal 
        List.sort      array w/o copying 
Collections.sort ─────────────────> Vector.sort ─────────────────> Arrays.sort 

Answer 2

您遇到的問題是不是與排序。

TimSort經由Arrays.sort稱爲其執行以下操作：

TimSort.sort(a, 0, a.length, c, null, 0, 0); 

所以可以看到該陣列TimSort越來越的大小爲0或1

Arrays.sort從Collections.sort調用，這做以下事情。

Object[] a = list.toArray(); 
Arrays.sort(a, (Comparator)c); 

所以你的集合沒有得到排序的原因是它返回一個空數組。因此，正在使用的集合通過返回一個空數組而不符合集合API。

你說你有一個持久層。所以這聽起來像問題是你正在使用的庫以懶惰的方式檢索實體，並且不會填充它的支持數組，除非必須。仔細看看你想要分類的集合，看看它是如何工作的。你原來的單元測試沒有顯示任何東西，因爲它不是要對生產中使用的相同集合進行分類。

Answer 3

等待修復錯誤https://bugs.eclipse.org/bugs/show_bug.cgi?id=446236。 獲取可用或快照時使用以下依賴項。

<dependency> 
    <groupId>org.eclipse.persistence</groupId> 
    <artifactId>eclipselink</artifactId> 
    <version>2.6.0</version> 
</dependency> 

在此之前使用的解決方法從問題：

if (docs instanceof IndirectList) { 
    IndirectList iList = (IndirectList)docs; 
    Object sortTargetObject = iList.getDelegateObject(); 
    if (sortTargetObject instanceof List<?>) { 
     List<Document> sortTarget=(List<Document>) sortTargetObject; 
     Collections.sort(sortTarget,comparator); 
    } 
} else { 
    Collections.sort(docs,comparator); 
} 

或指定渴望獲取在可能的情況：

// http://stackoverflow.com/questions/8301820/onetomany-relationship-is-not-working 
@OneToMany(cascade = CascadeType.ALL, mappedBy = "parentFolder", fetch=FetchType.EAGER)