Rückgabewert von DB ist multiple

Question

Ich entwickle EComerceDocumentManageSystem und brauche etwas Hilfe. Ich versuche es zu erklären. Ich bin eine Liste von Objekt haben nach

List<DeputeAppeal>deputeAppealList = deputeAppealService.individualSearch(deputeAppealForRequestDto); 
model.addAttribute("deputeAppealList", deputeAppealList); 

Service wie diese Suche

public List<DeputeAppeal> individualSearch(DeputeAppealForRequestDto deputeAppealForRequestDto) { 

     RequestForDeputeAppealSearch requestForDeputeAppealSearch = new RequestForDeputeAppealSearch(); 
     SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd"); 
     java.sql.Date incomeDateForDeputeAppealSQLSearch; 
     java.sql.Date outDateForDeputeAppealSQLSearch; 

     if(deputeAppealForRequestDto.getOutDate() == "") { 
      deputeAppealForRequestDto.setOutDate(null); 
     } else { 
      try { 
       Date outDateForSearch = format.parse(deputeAppealForRequestDto.getOutDate()); 
       outDateForDeputeAppealSQLSearch = new java.sql.Date(outDateForSearch.getTime()); 
       requestForDeputeAppealSearch.setOutDate(outDateForDeputeAppealSQLSearch); 
      } catch (ParseException e) { 
       e.printStackTrace(); 
      } 

     } 


     if(deputeAppealForRequestDto.getIncomingDate() == "") { 
      deputeAppealForRequestDto.setIncomingDate(null); 
     } else { 
      try { 
       Date incomingDateForSearch = format.parse(deputeAppealForRequestDto.getIncomingDate()); 
       incomeDateForDeputeAppealSQLSearch = new java.sql.Date(incomingDateForSearch.getTime()); 
       requestForDeputeAppealSearch.setIncomingDate(incomeDateForDeputeAppealSQLSearch); 
      } catch (ParseException e) { 
       e.printStackTrace(); 
      } 

     } 
     requestForDeputeAppealSearch.setOutNumber(deputeAppealForRequestDto.getOutNumber()); 
     requestForDeputeAppealSearch.setIncomeNumber(deputeAppealForRequestDto.getIncomeNumber()); 
     requestForDeputeAppealSearch.setNameAndAddressOfApplicant(deputeAppealForRequestDto.getNameAndAddressOfApplicant()); 
     requestForDeputeAppealSearch.setNameOfDepute(deputeAppealForRequestDto.getNameOfDepute()); 
     requestForDeputeAppealSearch.setSendingOrganization(deputeAppealForRequestDto.getSendingOrganization()); 
     requestForDeputeAppealSearch.setShortContentOfAppeal(deputeAppealForRequestDto.getShortContentOfAppeal()); 
     requestForDeputeAppealSearch.setMainWorker(deputeAppealForRequestDto.getMainWorker()); 
     requestForDeputeAppealSearch.setTypeOfDeputeAppeal(deputeAppealForRequestDto.getTypeOfDeputeAppeal()); 
     return deputeAppealDao.individualSearch(requestForDeputeAppealSearch); 
    } 

dao ist

public List<DeputeAppeal> individualSearch(RequestForDeputeAppealSearch deputeAppealForRequest) { 
     Criteria criteria = sessionDao.getSession().createCriteria(DeputeAppeal.class); 
     if(!deputeAppealForRequest.getOutNumber().equals("")) { 
      criteria.add(Restrictions.eq("outNumber", deputeAppealForRequest.getOutNumber())); 
     } 
     if(!deputeAppealForRequest.getIncomeNumber().equals("")) { 
      criteria.add(Restrictions.eq("incomeNumber", deputeAppealForRequest.getIncomeNumber())); 
     } 
     if(!deputeAppealForRequest.getNameAndAddressOfApplicant().equals("")) { 
      criteria.add(Restrictions.like("nameAndAddressOfApplicant", deputeAppealForRequest.getNameAndAddressOfApplicant())); 
     } 
     if(!deputeAppealForRequest.getNameOfDepute().equals("")) { 
      criteria.add(Restrictions.like("nameOfDepute", deputeAppealForRequest.getNameOfDepute())); 
     } 
     if(!deputeAppealForRequest.getSendingOrganization().equals("")) { 
      criteria.add(Restrictions.eq("sendingOrganization", deputeAppealForRequest.getSendingOrganization())); 
     } 
     if(deputeAppealForRequest.getOutDate() != null) { 
      criteria.add(Restrictions.eq("outDate", deputeAppealForRequest.getOutDate())); 
     } 
     if(deputeAppealForRequest.getIncomingDate() != null) { 
      criteria.add(Restrictions.eq("incomingDate", deputeAppealForRequest.getIncomingDate())); 
     } 
     if(!deputeAppealForRequest.getShortContentOfAppeal().equals("")) { 
      criteria.add(Restrictions.like("shortContentOfAppeal", deputeAppealForRequest.getShortContentOfAppeal())); 
     } 
     if(deputeAppealForRequest.getTypeOfDeputeAppeal() != null) { 
      criteria.add(Restrictions.eq("typeOfDeputeAppeal", deputeAppealForRequest.getTypeOfDeputeAppeal())); 
     } 
     if(!deputeAppealForRequest.getMainWorker().equals("")) { 
      criteria.add(Restrictions.eq("mainWorker", deputeAppealForRequest.getMainWorker())); 
     } 
     return criteria.list(); 
    } 

, wenn ich diese Methoden verwenden, bin für die Suche funktioniert gut, aber es System Eine Eigenschaft fügt jedem Dokument eine Datei hinzu. Sehen Sie wie diese

@RequestMapping(value = "/uploadingPageFileForDeputeAppeal", method = RequestMethod.POST) 
    public String uploadFile(@RequestParam("file") MultipartFile file, 
          @RequestParam(value = "id", required = true) int id, 
          Model model){ 
     LOGGER.debug("Receive request to add file"); 
     if(!file.isEmpty()){ 
      try { 
       byte [] bytes = file.getBytes(); 
       DeputeAppeal deputeAppeal = deputeAppealService.getById(id); 
       //Creating the directory to store file 
       String path = System.getProperty("user.home"); 
       File directory = new File(path + File.separator + "DeputeAppealsFiles" + File.separator + deputeAppeal.getIncomeNumber()); 
       if(!directory.exists()) 
        directory.mkdirs(); 

       // Create the file on server 
       File serverFile = new File(directory.getAbsolutePath() + File.separator + file.getOriginalFilename()); 
       BufferedOutputStream stream = new BufferedOutputStream(
         new FileOutputStream(serverFile)); 
       stream.write(bytes); 
       stream.close(); 

       DeputeAppealFiles deputeAppealFiles = new DeputeAppealFiles(); 
       deputeAppealFiles.setDeputeAppeal(deputeAppeal); 
       deputeAppealFiles.setFilePath(serverFile.getAbsolutePath()); 
       deputeAppealFiles.setFileType(file.getContentType()); 
       deputeAppeal.getDeputeAppealFiles().add(deputeAppealFiles); 
       deputeAppealService.editFilePath(deputeAppealFiles); 
       model.addAttribute("deputeAppealId", deputeAppeal); 
       model.addAttribute("fileDirection", deputeAppealFiles.getFilePath()); 

      } catch (Exception e) { 
       return "You failed to upload " + file.getName() + " => " + e.getMessage(); 
      } 
     } else { 
      return "You failed to upload " + file.getName() 
        + " because the file was empty."; 
     } 

     return "deputeAppealView/addedFile"; 
    } 

so nach einer Datei Dokument alle in der Suche Hinzufügen sieht auch gut aus, aber wenn ich das Hinzufügen von zwei Dateien zu jedem Dokument, Ergebnisseite zeigt mir zwei die gleichen Objekte sucht, sind wenn drei Dateien hinzufügen, es zeige drei Objekte. Ich bin verwirren, weil ich

Entities nur ein Objekt benötigen unter

@Entity 
@Table(name = "DEPUTES_APPEAL") 
public class DeputeAppeal extends Appeal implements Serializable { 

    private static final long serialVersionUID = -5527566248002296042L; 

    @Id 
    @Column(name = "DeputeAppeal_ID") 
    @GeneratedValue 
    private int id; 

    @Column(name = "TypeOfDeputeAppeal") 
    private String typeOfDeputeAppeal; 

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

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

    @Column(name = "outDate") 
    private Date outDate; 

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

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

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

    @Column(name = "incomingDate") 
    private Date incomingDate; 

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

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

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

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

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

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

    @Column(name = "dateForCheck") 
    private Date dateForCheck; 

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

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

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

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

    @OneToMany(mappedBy = "deputeAppeal", cascade = CascadeType.ALL, fetch = FetchType.EAGER) 
    private List<DeputeAppealFiles> deputeAppealFiles = new ArrayList<DeputeAppealFiles>(); 

und

@Entity 
@Table(name = "DeputeAppealFiles") 
public class DeputeAppealFiles implements Serializable { 

    private static final long serialVersionUID = -5227566248002296042L; 

    @Id 
    @Column(name = "DeputeAppealFiles_ID", unique = true, nullable = false) 
    @GeneratedValue(strategy = GenerationType.IDENTITY) 
    private int deputeAppealFilesId; 

    @Column(name = "FilePath") 
    private String filePath; 

    @Column(name = "FileType") 
    private String fileType; 

    @ManyToOne 
    @JoinColumn(name = "DeputeAppeal_ID") 
    private DeputeAppeal deputeAppeal; 

Kann jemand helfen? Ich bin in Java verloren)

Answer 1

Dieses Problem kommt tatsächlich von DB-Ebene. Da Sie FetchType.EAGER in Ihrem @OneToMany haben, generiert Hibenate Abfrage mit Join, die cartesian productDEPUTES_APPEAL und DeputeAppealFiles erzeugt. Aus diesem Grund erhalten Sie dieselbe Entität mehrere Male.

Um dies zu beheben, können Sie entweder:

1. FetchType.EAGER
2. Verwenden Ergebnis Transformator criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY)

P. S. entfernen Sie fragen Titel nicht mit Ihrer tatsächlichen Frage korrelieren.