Копирование заметок занимает очень много времени


Я работаю на Весна-MVC-приложения, в котором мы заметим, как функциональность. Заметки могут иметь вложения, истории и т. д.
Есть способ скопировать ноты. Когда заметка имеет большое количество насадок (большой или маленький), он принимает нагрузку чертовски время для того, чтобы скопировать (около 5 минут для заметок с 341 вложения).

Вчера я оставила вопрос об этом здесь, и советы, чтобы очистить сессии и очистить кэш же, как и размер пакета помогла. Метод по крайней мере работает сейчас. Но 5 минут-это недопустимо.

Я хотел бы знать, что я делаю неправильно и как я могу улучшить его. В методе, вы увидите, что я копирую свойства объектов mańually. Когда я использую функцию копирования в зернах, он бросает ошибки мне для зависимых объектов(один-ко-многим).

Код длинный и я отправляю config как хорошо быть тщательным. Примечание: Я пропускаю Google Диск и Dropbox код, так как он не используется и является более низкий приоритет. Метод addAttachmentForCopy() занимает много времени.

root-context.xml:

 <beans:bean id="dataSource" class="com.zaxxer.hikari.HikariDataSource"  destroy-method="close">
    <beans:property name="dataSourceClassName" value="org.postgresql.ds.PGSimpleDataSource"/>

   <beans:property name="maximumPoolSize" value="100" />
    <beans:property name="maxLifetime" value="300000" />
    <beans:property name="idleTimeout" value="300000" />
    <beans:property name="dataSourceProperties">
        <beans:props>
            <beans:prop key="url">jdbc:postgresql://localhost:PORT_NOS/DB_NAME</beans:prop>
            <beans:prop key="user">USERNAME</beans:prop>
            <beans:prop key="password">PASSWORD</beans:prop>

        </beans:props>
    </beans:property>
</beans:bean>

<!-- Hibernate 4 SessionFactory Bean definition -->
<beans:bean id="hibernate4AnnotatedSessionFactory"
            class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
    <beans:property name="dataSource" ref="dataSource"/>
    <beans:property name="packagesToScan" value="com.ourapp.spring.model"/>
    <beans:property name="hibernateProperties">
        <beans:props>
            <beans:prop key="hibernate.dialect">org.hibernate.dialect.PostgreSQL9Dialect</beans:prop>
            <beans:prop key="hibernate.show_sql">false</beans:prop>
            <beans:prop key="hibernate.jdbc.batch_size">50</beans:prop>
            <beans:prop key="hibernate.hbm2ddl.auto">update</beans:prop>
            <beans:prop key="cache.use_second_level_cache">true</beans:prop>
            <beans:prop key="cache.use_query_cache">true</beans:prop>
            <beans:prop key="hibernate.order_updates">true</beans:prop>
            <beans:prop key="show_sql">false</beans:prop>
        </beans:props>
    </beans:property>

</beans:bean>

GroupNotesServiceImpl duplicateNote:

@Override
public int duplicateGroupNote(int groupNoteId, int sectionId, long groupAccountId, boolean duplicateFlag,
                              boolean sendNotification, double sortValue, boolean copyFlag) {
    Person person = this.personService.getCurrentlyAuthenticatedUser();
    GroupNotes savedNote = this.groupNotesDAO.getGroupNoteById(groupNoteId);
    GroupSection originSection = this.groupSectionService.getGroupSectionById(savedNote.getOwnedSectionId());
    GroupCanvas originCanvas = this.groupCanvasService.getCanvasById(originSection.getCurrentCanvasId());
    GroupAccount originAccount = this.groupAccountService.getGroupById(originCanvas.getGroupAccountId());
    GroupMembers etherPadMember = this.groupMembersService.returnMembersMatchingUsernameAccountId(person.getUsername(), groupAccountId);
    GroupAccount destinationGroupAccount = this.groupAccountService.getGroupById(groupAccountId);
    GroupSection groupSection = this.groupSectionService.getGroupSectionById(sectionId);
    GroupCanvas groupCanvas = this.groupCanvasService.getCanvasById(groupSection.getCurrentCanvasId());
    GroupAccount groupAccount = this.groupAccountService.getGroupById(groupCanvas.getGroupAccountId());
    Permission permission = this.permissionService.getPermissionForMember(groupAccount.getGroupId());
    GroupMembers actionMember = this.groupMembersService.returnMembersMatchingUsernameAccountId(person.getUsername(), originAccount.getGroupId());

    String teamAndBoardNameOrigin = originAccount.getGroupName() + ", " + originCanvas.getMcanvasname();
    String teamAndBoardTextOrigin = savedNote.getMnotetag() + ", Note Verschoben";

    String teamAndBoardNameDestination = groupAccount.getGroupName() + ", " + groupCanvas.getMcanvasname();

    List<Object> toSendObjectList = new ArrayList<>();
    final int[] updatedNoteId = new int[1];
    if (permission.isAddNote()) {
        this.activityCounterService.saveGroupNotActivity(groupNoteId);
        this.noteActivityService.saveGroupNotActivity(actionMember.getMemberid());
        GroupNotes duplicateNote;
        if (duplicateFlag) {
            duplicateNote = new GroupNotes("Kopie von: " + savedNote.getMnotetag(), "",
                    sortValue, savedNote.getMnotecolor(),
                    new Timestamp(System.currentTimeMillis()), savedNote.getCreatorId(),
                    savedNote.getNoteCreatorEmail(), savedNote.getNoteDate());
        } else {
            duplicateNote = new GroupNotes(savedNote.getMnotetag(), "",
                    sortValue, savedNote.getMnotecolor(),
                    new Timestamp(System.currentTimeMillis()), savedNote.getCreatorId(),
                    savedNote.getNoteCreatorEmail(), savedNote.getNoteDate());
        }
        duplicateNote.setAttachCount(savedNote.getAttachCount());
        duplicateNote.setCanvasUrl(savedNote.getCanvasUrl());
        duplicateNote.setCollapse(savedNote.isCollapse());
        duplicateNote.setDisabledSortId(savedNote.getDisabledSortId());
        duplicateNote.setEndIsMilestone(savedNote.isEndIsMilestone());
        duplicateNote.setGannt(false);
        duplicateNote.setGanntOrder(0);
        duplicateNote.setGanttDuration(0);
        duplicateNote.setGanttStatus("");
        duplicateNote.setRandomNos(UUID.randomUUID().toString());
        duplicateNote.setLevel(0);
        duplicateNote.setNoteDisabled(savedNote.isNoteDisabled());
        duplicateNote.setNoteInActive(savedNote.isNoteInActive());
        duplicateNote.setNoteTarget(savedNote.getNoteTarget());
        duplicateNote.setUploader(savedNote.getUploader());
        duplicateNote.setCanvasId(groupCanvas.getMcanvasid());
        duplicateNote.setGroupId(groupAccount.getGroupId());
        duplicateNote.setUrgent(savedNote.isUrgent());
        duplicateNote.setTags(savedNote.getTags());
        duplicateNote.setErledigtPersonId(savedNote.getErledigtPersonId());
        duplicateNote.setErledigtTimestamp(savedNote.getErledigtTimestamp());
        duplicateNote.setFinished(savedNote.isFinished());
        duplicateNote.setProcessing(true);

        try {
            if ((savedNote.getPadId() != null) && (!savedNote.getPadId().isEmpty())) {
                String text = this.initailizeEpadClient.getTextForGivePad(savedNote.getPadId());
                //text = Jsoup.parse(text).text();
                String padID = this.initailizeEpadClient.createPadObjectsWithHtmlForDuplicateNotes(etherPadMember.getSessionData(), text);

                duplicateNote.setPadId(padID);
                //this.initailizeEpadClient.copyPad(savedNote.getPadId(), padID);
                String oldText = this.initailizeEpadClient.getTextForGivePad(padID);
                if (oldText != null) {
                    duplicateNote.setMnotetext(oldText);
                }
            } else {
                duplicateNote.setMnotetext(savedNote.getMnotetext());
            }
        } catch (Exception e) {
            e.printStackTrace();

            duplicateNote.setMnotetext(savedNote.getMnotetext());
        }

        if (!duplicateFlag) {
            duplicateNote.setNoteNumber(savedNote.getNoteNumber());
            duplicateNote.setCreatorId(savedNote.getCreatorId());
        } else {
            duplicateNote.setCreatorId(person.getId());
            this.groupCanvasService.directUpdateGroupCanvas(groupCanvas);
            groupCanvas = this.groupCanvasService.getCanvasById(groupCanvas.getMcanvasid());
            groupCanvas.setNoteCount(groupCanvas.getNoteCount() + 1);
            this.groupCanvasService.directUpdateGroupCanvas(groupCanvas);
            duplicateNote.setNoteNumber(groupCanvas.getNoteCount());
        }
        duplicateNote.setFinished(savedNote.isFinished());
        duplicateNote.setExcelData(savedNote.getExcelData());
        if (savedNote.getZugwisenPersonId() != 0) {
            Person zugweisedUser = this.personService.getPersonById(savedNote.getZugwisenPersonId());
            if (zugweisedUser != null) {
                GroupMembers groupMembers = this.groupMembersService.returnMembersMatchingUsernameAccountId(zugweisedUser.getUsername(), groupAccountId);
                if (groupMembers != null) {
                    duplicateNote.setZugwisenPersonId(savedNote.getZugwisenPersonId());
                    duplicateNote.setZugwisenPersonTimestamp(savedNote.getZugwisenPersonTimestamp());
                    duplicateNote.setPersonWhoZugweised(savedNote.getPersonWhoZugweised());
                } else {
                    duplicateNote.setZugwisenPersonId(0);
                    duplicateNote.setZugwisenPersonTimestamp(null);
                    duplicateNote.setPersonWhoZugweised(0);
                }
            }
        }
        duplicateNote.setStartDateTimestamp(savedNote.getStartDateTimestamp());
        duplicateNote.setPrefix(savedNote.getPrefix());
        duplicateNote.setTaskRelations(savedNote.getTaskRelations());
        duplicateNote.setPrivateNoteFlag(savedNote.isPrivateNoteFlag());
        duplicateNote.setProcessing(true);
        try {
            if (duplicateFlag) {
                updatedNoteId[0] = this.groupNotesDAO.saveGroupNoteAndReturnId(duplicateNote, sectionId);
            } else {
                updatedNoteId[0] = this.groupNotesDAO.saveGroupNoteAndReturnId(duplicateNote, sectionId);
                if (originAccount.getGroupId() != groupAccount.getGroupId()) {
                    this.activityCounterService.saveGroupNotActivity(updatedNoteId[0]);
                    GroupMembers groupMembers = this.groupMembersService.returnMembersMatchingUsernameAccountId(person.getUsername(), groupAccount.getGroupId());
                    if (groupMembers != null) {
                        this.noteActivityService.saveGroupNotActivity(groupMembers.getMemberid());
                    }
                }
            }
            sendControlNotificationsForNote(null, updatedNoteId[0], groupSection.getMsectionid(), groupCanvas.getMcanvasid(), destinationGroupAccount.getGroupId(), false);
            GroupNotes databaseNoteObject = this.groupNotesDAO.getGroupNoteById(updatedNoteId[0]);
            this.groupAttachmentsService.saveIndexes(databaseNoteObject.getMnotetext() + " " + databaseNoteObject.getTags(), databaseNoteObject.getMnotetag(), null, groupAccount.getGroupId(), true, databaseNoteObject.getMnoticesid());
            List<Integer> noteFollowers = this.noteFollowService.getNoteFollowsForNote(groupNoteId);
            if (noteFollowers != null) {
                for (Integer id : noteFollowers) {
                    this.noteFollowService.addNoteFollow(id, updatedNoteId[0]);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();

        }

        List<GroupNoteHistory> groupNoteHistoryList = this.groupNoteHistoryService.getNoteHistoryById(savedNote.getMnoticesid());
        try {
            int i = 0;
            for (GroupNoteHistory groupNoteHistory : groupNoteHistoryList) {
                i++;
                GroupNoteHistory targetGroupHistory = new GroupNoteHistory();
                targetGroupHistory.setChangedMessage(groupNoteHistory.getChangedMessage());
                targetGroupHistory.setEditorId(groupNoteHistory.getEditorId());
                targetGroupHistory.setFirstName(groupNoteHistory.getFirstName());
                targetGroupHistory.setMnoteEditDate(groupNoteHistory.getMnoteEditDate());
                targetGroupHistory.setNestedComment(groupNoteHistory.isNestedComment());
                targetGroupHistory.setNestedId(groupNoteHistory.getNestedId());
                targetGroupHistory.setNestedCommentList(groupNoteHistory.getNestedCommentList());
                targetGroupHistory.setNewNoteHeadline(groupNoteHistory.getNewNoteHeadline());
                targetGroupHistory.setNewNoteText(groupNoteHistory.getNewNoteText());
                targetGroupHistory.setOldHeadLine(groupNoteHistory.getOldHeadLine());
                targetGroupHistory.setOldText(groupNoteHistory.getOldText());
                targetGroupHistory.setParent(groupNoteHistory.isParent());
                targetGroupHistory.setPinned(groupNoteHistory.isPinned());
                targetGroupHistory.setPinnedTime(groupNoteHistory.getPinnedTime());
                targetGroupHistory.setWhatHasChanged(groupNoteHistory.getWhatHasChanged());

                int saveId = this.groupNoteHistoryService.addNoteHistory(targetGroupHistory, updatedNoteId[0]);
                if (saveId != 0) {
                    toSendObjectList.add(this.groupNoteHistoryService.getGroupNoteHistoryById(saveId));
                }
                if (groupNoteHistory.isParent()) {
                    int j = 0;
                    List<GroupNoteHistory> nestedList = this.groupNoteHistoryService.getChildHistoryEntries(groupNoteHistory.getMhistoryid());
                    for (GroupNoteHistory nestedHistory : nestedList) {
                        j++;
                        GroupNoteHistory nestedHistoryEntry = new GroupNoteHistory();
                        nestedHistoryEntry.setFirstName(nestedHistory.getFirstName());
                        nestedHistoryEntry.setChangedMessage(nestedHistory.getChangedMessage());
                        nestedHistoryEntry.setEditorId(nestedHistory.getEditorId());
                        nestedHistoryEntry.setFirstName(nestedHistory.getFirstName());
                        nestedHistoryEntry.setMnoteEditDate(nestedHistory.getMnoteEditDate());
                        nestedHistoryEntry.setNestedComment(nestedHistory.isNestedComment());
                        nestedHistoryEntry.setNestedCommentList(nestedHistory.getNestedCommentList());
                        nestedHistoryEntry.setNewNoteHeadline(nestedHistory.getNewNoteHeadline());
                        nestedHistoryEntry.setNewNoteText(nestedHistory.getNewNoteText());
                        nestedHistoryEntry.setOldHeadLine(nestedHistory.getOldHeadLine());
                        nestedHistoryEntry.setOldText(nestedHistory.getOldText());
                        nestedHistoryEntry.setParent(nestedHistory.isParent());
                        nestedHistoryEntry.setPinned(nestedHistory.isPinned());
                        nestedHistoryEntry.setPinnedTime(nestedHistory.getPinnedTime());
                        nestedHistoryEntry.setWhatHasChanged(nestedHistory.getWhatHasChanged());
                        nestedHistoryEntry.setNestedId(saveId);
                        int nestedId = this.groupNoteHistoryService.addNoteHistory(nestedHistoryEntry, updatedNoteId[0]);
                        if (nestedId != 0) {
                            toSendObjectList.add(this.groupNoteHistoryService.getGroupNoteHistoryById(nestedId));
                        }
                        if (j % 50 == 0) {
                            this.groupNoteHistoryService.flushSession();
                        }

                    }
                }
                if (i % 50 == 0) {
                    this.groupNoteHistoryService.flushSession();
                }

            }
        } catch (Exception e) {
          e.printStackTrace();

        }
        this.groupNoteHistoryService.flushSession();
        GroupNotes dbNote = getGroupNoteObjectById(updatedNoteId[0]);
        try {
            try {
                List<GroupAttachments> groupAttachmentsSet = this.groupAttachmentsService.getAttachmenByNoteId(groupNoteId);
                Collections.reverse(groupAttachmentsSet);
                boolean flag;
                int i = 0;
                for (GroupAttachments groupAttachments : groupAttachmentsSet) {
                    flag = false;
                    i++;
                    if ((groupAttachments.getApiUsed() == null) || (groupAttachments.getApiUsed().isEmpty())) {
                        flag = true;
                        GroupAttachments attachmentWithData = this.groupAttachmentsService
                                .getAttachmenById(groupAttachments.getGroupAttachId());
                        if (attachmentWithData != null) {
                                this.groupAttachmentsService.addAttachmentForCopy(attachmentWithData, dbNote, false,
                                        groupSection, groupCanvas, destinationGroupAccount);
                        }
                    }


                    if (!(groupAttachments.getApiUsed() == null)) {
                        if (!(groupAttachments.getApiUsed().isEmpty())) {
                            if ((groupAttachments.getApiUsed().equals("google")) && (!flag)) {
                                flag = true;

                                if (destinationGroupAccount.isUseDrive()) {
                                    InputStream inputStream = this.driveQuickstart.downloadFile(groupAttachments
                                            .getGroupAttachId(), destinationGroupAccount.getGroupId(), false);
                                    byte[] bytes = IOUtils.toByteArray(inputStream);

                                    this.driveQuickstart.insertFile(bytes, groupAttachments.getFileName(),
                                            groupAttachments.getMimeType(), groupAttachments.getFileSize(),
                                            updatedNoteId[0], destinationGroupAccount.getGroupId(),
                                            "", false, groupAttachments);

                                }
                            }
                        }
                    }

                    if (!(groupAttachments.getApiUsed() == null)) {
                        if (!(groupAttachments.getApiUsed().isEmpty())) {
                            if (((groupAttachments.getApiUsed().equals("dropbox")) && (!flag))) {
                                flag = true;

                                if (destinationGroupAccount.isUseDropbox()) {
                                    InputStream inputStream = this.dropboxTask.downloadFile(groupAttachments
                                            .getGroupAttachId()
                                            , false);
                                    byte[] bytes = IOUtils.toByteArray(inputStream);

                                    this.dropboxTask.insertFileAsByteArray(bytes, groupAttachments.getFileName(),
                                            groupAttachments.getMimeType(),
                                            groupAttachments.getFileSize(), "", updatedNoteId[0],
                                            destinationGroupAccount.getGroupId(), false, groupAttachments);
                                }
                            }
                        }
                    }

                    if (!flag) {
                        if (!(groupAttachments.getApiUsed() == null)) {
                            if (!(groupAttachments.getApiUsed().isEmpty())) {
                                if ((groupAttachments.getApiUsed().equals("google"))) {
                                    flag = true;
                                    InputStream inputStream = this.driveQuickstart.downloadFile(groupAttachments
                                            .getGroupAttachId(), destinationGroupAccount.getGroupId(), true);

                                    byte[] bytes = IOUtils.toByteArray(inputStream);
                                    groupAttachments.setSendAttachment(bytes);
                                    this.groupAttachmentsService.addAttachmentForCopy(groupAttachments, dbNote, false,
                                            groupSection, groupCanvas, destinationGroupAccount);
                                }
                            }
                        }

                        if (!(groupAttachments.getApiUsed() == null)) {
                            if (!(groupAttachments.getApiUsed().isEmpty())) {
                                if (groupAttachments.getApiUsed().equals("dropbox")) {
                                    flag = true;


                                    InputStream inputStream = this.dropboxTask.downloadFile(groupAttachments.getGroupAttachId()
                                            , false);
                                    byte[] bytes = IOUtils.toByteArray(inputStream);

                                    groupAttachments.setSendAttachment(bytes);
                                    this.groupAttachmentsService.addAttachmentForCopy(groupAttachments, dbNote, false,
                                            groupSection, groupCanvas, destinationGroupAccount);
                                }
                            }
                        }

                        if (!flag) {
                            GroupAttachments attachmentWithData = this.groupAttachmentsService
                                    .getAttachmenById(groupAttachments.getGroupAttachId());
                            if (attachmentWithData != null) {
                                this.groupAttachmentsService.addAttachmentForCopy(attachmentWithData, dbNote, false,
                                        groupSection, groupCanvas, destinationGroupAccount);
                            }
                        }

                    }
                    if (i % 50 == 0) {
                        this.groupNoteHistoryService.flushSession();
                    }

                }
            } catch (Exception e) {
                 e.printStackTrace();

            }

        } catch (Exception e) {
            e.printStackTrace();

        }
        this.groupNoteHistoryService.flushSession();


        if ((!duplicateFlag)) {
            final GroupCanvas finalGroupCanvas = groupCanvas;

            Thread saveThread = new Thread(() -> {
                List<GroupMembers> groupMembersList = this.groupMembersService.returnGroupMembers(groupAccount.getGroupId());
                boolean archiveSuccess = this.groupNotesDAO.setNoteStatus(groupNoteId, true);
                if (archiveSuccess && sendNotification) {
                    for (GroupMembers groupMembers : groupMembersList) {
                        if (!(person.getUsername().equals(groupMembers.getMemberUsername()))) {
                            NotificationType notificationType = this.notificationTypeService.getNotificationTypeForMember(groupMembers.getMemberid());
                            if (notificationType.isRemoveNote()) {
                                Notification notification = this.notificationService.createNotification(person.getId(), false, "",
                                        groupAccount.getGroupName() + ", " + finalGroupCanvas.getMcanvasname(),
                                        "", "", originSection.getMsectionid(),
                                        originCanvas.getMcanvasid(), savedNote.getMnoticesid(), savedNote.getMnotecolor(), groupAccountId);
                                notification.setBroadCast(false);
                                notification.setZugweisedPersonId(savedNote.getZugwisenPersonId());
                                notification.setSendNoteId(groupNoteId);
                                notification.setRemove(true);
                                notification.setSubject(teamAndBoardNameOrigin);
                                notification.setText(teamAndBoardTextOrigin);
                                this.notificationService.addNotification(notification,
                                        groupMembers.getMemberid());
                            }

                            if (groupMembers.isNotifyWhenNoteDeleted()) {
                                if (!(person.getUsername().equals(groupMembers.getMemberUsername()))) {
                                    Person memberPerson = this.personService.findPersonByUsername(groupMembers.getMemberUsername());
                                    Permission emailPerm = this.permissionService.getPermissionByEmailAndGroupId(groupMembers.getTempgroupaccountid(), memberPerson.getId());
                                    if (emailPerm != null) {
                                        if ((emailPerm.isAllNotes()) ||
                                                (savedNote.getZugwisenPersonId() == groupMembers.getTransientPerson().getId())) {
                                            boolean allowed = this.canvasAllowedService.checkIfCanvasAllowedForMember(groupMembers.getMemberid(), originCanvas.getMcanvasid());
                                            if (allowed) {
                                                sendNoteDeletionEmail(originAccount.getGroupName(),
                                                        groupMembers.getMemberUsername(), person.getFirstName(),
                                                        savedNote.getMnotetag(), originCanvas.getMcanvasname(), originSection.getMsectionname(),
                                                        originCanvas.getMcanvasid(),
                                                        savedNote, originAccount.getGroupId(), person.getId());
                                            }
                                        }
                                    }
                                }
                            }
                        } else {
                            sendControlNotificationsForNote(null, groupNoteId, originSection.getMsectionid(), originCanvas.getMcanvasid(), originAccount.getGroupId(), true);
                        }
                    }
                } else {
                    sendControlNotificationsForNote(null, groupNoteId, originSection.getMsectionid(), originCanvas.getMcanvasid(), originAccount.getGroupId(), true);
                }
            });
            saveThread.start();
        }

        GroupNotes updatedNote =
                this.groupNotesDAO.getGroupNoteById(updatedNoteId[0]);
        if (!duplicateFlag) {
            int copyHistoryID = this.groupNoteHistoryService.addNoteHistory(new GroupNoteHistory(new Timestamp(System.currentTimeMillis()),
                    "cut", "Diese Note wurde in das Board " + groupCanvas.getMcanvasname() + " ausgeschnitten",
                    person.getId()), groupNoteId);
            GroupNoteHistory copyHistory = this.groupNoteHistoryService.getGroupNoteHistoryById(copyHistoryID);
            toSendObjectList.add(copyHistory);

            List<GroupMembers> groupMembersList = this.groupMembersService.returnGroupMembers(originAccount.getGroupId());
            for (GroupMembers groupMembers : groupMembersList) {
                if (!person.getUsername().equals(groupMembers.getMemberUsername())) {
                    NotificationType notificationType = this.notificationTypeService.getNotificationTypeForMember(groupMembers.getMemberid());
                    if (notificationType.isNoteCopy()) {
                        Notification copyNotification = new Notification(teamAndBoardNameOrigin + "Note Ausgeschnitten", "Note Ausgeschnitten",
                                originSection.getMsectionid(), originCanvas.getMcanvasid(),
                                person.getId(), false, new Timestamp(System.currentTimeMillis()), "copy",
                                savedNote.getMnotecolor(), true, originAccount.getGroupId());
                        copyNotification.setSendNoteId(groupNoteId);
                        copyNotification.setObjects(toSendObjectList);
                        copyNotification.setSubject(teamAndBoardNameOrigin);
                        copyNotification.setText(teamAndBoardTextOrigin);
                        this.chatService.sendNotification(copyNotification, groupMembers.getMemberid());
                    }
                }
            }

            // toSendObjectList.clear();


            int pasteId = this.groupNoteHistoryService.addNoteHistory(new GroupNoteHistory(new Timestamp(System.currentTimeMillis()),
                    "paste", "Eingefügt in: " + groupAccount.getGroupName() + ", " + groupCanvas.getMcanvasname() + ", " + groupSection.getMsectionname(),
                    person.getId()), updatedNote.getMnoticesid());
            GroupNoteHistory pasteHistory = this.groupNoteHistoryService.getGroupNoteHistoryById(pasteId);
            toSendObjectList.add(pasteHistory);

            List<GroupMembers> updatedGroupMembersList = this.groupMembersService.returnGroupMembers(groupAccountId);
            for (GroupMembers groupMembers : updatedGroupMembersList) {
                if (!person.getUsername().equals(groupMembers.getMemberUsername())) {
                    Notification pasteNotification = new Notification(teamAndBoardNameDestination + "Note Eingefügt", "Note Eingefügt",
                            groupSection.getMsectionid(), groupCanvas.getMcanvasid(),
                            person.getId(), false, new Timestamp(System.currentTimeMillis()), "copy",
                            savedNote.getMnotecolor(), true, groupAccount.getGroupId());
                    pasteNotification.setSendNoteId(updatedNoteId[0]);
                    pasteNotification.setObjects(toSendObjectList);
                    pasteNotification.setSubject(teamAndBoardNameDestination);
                    pasteNotification.setText(updatedNote.getMnotetag() + ", Note Eingefügt");
                    this.chatService.sendNotification(pasteNotification, groupMembers.getMemberid());

                }
            }


        } else {
            if (!copyFlag) {
                int originCopyId = this.groupNoteHistoryService.addNoteHistory(new GroupNoteHistory(new Timestamp(System.currentTimeMillis()),
                        "copy", "Diese Note wurde dupliziert",
                        person.getId()), groupNoteId);
                List<Object> objects = new ArrayList<>();
                objects.add(this.groupNoteHistoryService.getGroupNoteHistoryById(originCopyId));
                sendControlNotificationsForNote(objects, groupNoteId, originSection.getMsectionid(), originCanvas.getMcanvasid(), originAccount.getGroupId(), false);
            } else {
                int originCopyId = this.groupNoteHistoryService.addNoteHistory(new GroupNoteHistory(new Timestamp(System.currentTimeMillis()),
                        "copy", "Diese Note wurde kopiert",
                        person.getId()), groupNoteId);
                List<Object> objects = new ArrayList<>();
                objects.add(this.groupNoteHistoryService.getGroupNoteHistoryById(originCopyId));
                sendControlNotificationsForNote(objects, groupNoteId, originSection.getMsectionid(), originCanvas.getMcanvasid(), originAccount.getGroupId(), false);
            }


            int copyHistoryID = this.groupNoteHistoryService.addNoteHistory(new GroupNoteHistory(new Timestamp(System.currentTimeMillis()),
                    "copy", "Kopiert von: " + originAccount.getGroupName() + ", " + originCanvas.getMcanvasname() + ", " + originSection.getMsectionname(),
                    person.getId()), updatedNote.getMnoticesid());

            GroupNoteHistory copyHistory = this.groupNoteHistoryService.getGroupNoteHistoryById(copyHistoryID);
            toSendObjectList.add(copyHistory);
            if (!sendNotification) {
                List<GroupMembers> groupMembersList = this.groupMembersService.returnGroupMembers(originAccount.getGroupId());
                for (GroupMembers groupMembers : groupMembersList) {
                    if (!person.getUsername().equals(groupMembers.getMemberUsername())) {
                        NotificationType notificationType = this.notificationTypeService.getNotificationTypeForMember(groupMembers.getMemberid());
                        if (notificationType.isNoteCopy()) {
                            Notification copyNotification = new Notification(teamAndBoardNameOrigin + "Note Kopiert", "Note kopiert",
                                    originSection.getMsectionid(), originCanvas.getMcanvasid(),
                                    person.getId(), false, new Timestamp(System.currentTimeMillis()), "copy",
                                    savedNote.getMnotecolor(), true, originAccount.getGroupId());
                            copyNotification.setSendNoteId(updatedNoteId[0]);
                            copyNotification.setObjects(toSendObjectList);
                            copyNotification.setSubject(teamAndBoardNameOrigin);
                            copyNotification.setText(teamAndBoardTextOrigin);
                            this.chatService.sendNotification(copyNotification, groupMembers.getMemberid());
                        }
                    }
                }
            }


            int pasteId = this.groupNoteHistoryService.addNoteHistory(new GroupNoteHistory(new Timestamp(System.currentTimeMillis()),
                    "paste", "Eingefügt in: " + groupAccount.getGroupName() + ", " + groupCanvas.getMcanvasname() + ", " + groupSection.getMsectionname(),
                    person.getId()), updatedNote.getMnoticesid());

            GroupNoteHistory pasteHistory = this.groupNoteHistoryService.getGroupNoteHistoryById(pasteId);
            toSendObjectList.add(pasteHistory);
            if (!sendNotification) {
                List<GroupMembers> updatedGroupMembersList = this.groupMembersService.returnGroupMembers(groupAccountId);
                for (GroupMembers groupMembers : updatedGroupMembersList) {
                    if (!person.getUsername().equals(groupMembers.getMemberUsername())) {
                        Notification pasteNotification = new Notification("Note Eingefügt: " + savedNote.getMnotetag(), "Note kopiert",
                                originSection.getMsectionid(), originCanvas.getMcanvasid(),
                                person.getId(), false, new Timestamp(System.currentTimeMillis()), "copy",
                                savedNote.getMnotecolor(), true, originAccount.getGroupId());
                        pasteNotification.setSendNoteId(updatedNoteId[0]);
                        pasteNotification.setObjects(toSendObjectList);
                        this.chatService.sendNotification(pasteNotification, groupMembers.getMemberid());

                    }
                }
            }
        }


        GroupSection updatedSection = this.groupSectionService.getGroupSectionById(updatedNote.getOwnedSectionId());
        GroupCanvas updatedCanvas = this.groupCanvasService.getCanvasById(updatedSection.getCurrentCanvasId());
        final GroupCanvas finalGroupCanvas1 = groupCanvas;
        if (sendNotification) {
            List<GroupMembers> newMemberList = this.groupMembersService.returnGroupMembers(groupAccountId);
            for (GroupMembers members : newMemberList) {
                if (members.getMemberUsername().equals(person.getUsername())) {
                    sendControlNotificationsForNote(toSendObjectList, updatedNoteId[0], groupSection.getMsectionid(), finalGroupCanvas1.getMcanvasid(), destinationGroupAccount.getGroupId(), false);
                } else {
                    NotificationType notificationType = this.notificationTypeService.getNotificationTypeForMember(members.getMemberid());
                    if (notificationType.isAddNote()) {
                        Notification notification = this.notificationService.createNotification(person.getId(), true, "/section/listing/" +
                                        updatedCanvas.getMcanvasid() + "?note="
                                        + updatedNote.getMnoticesid(),
                                groupAccount.getGroupName() + ", " + updatedCanvas.getMcanvasname(), "", "note", updatedSection.getMsectionid(),
                                updatedCanvas.getMcanvasid(), 0, updatedNote.getMnotecolor(), destinationGroupAccount.getGroupId());
                        notification.setBroadCast(false);
                        notification.setZugweisedPersonId(updatedNote.getZugwisenPersonId());
                        notification.setNoteid(updatedNoteId[0]);
                        notification.setSendNoteId(updatedNoteId[0]);
                        notification.setObjects(toSendObjectList);
                        if (duplicateFlag) {
                            notification.setText("Note kopiert/ eingefügt: <span class='bold'>" + updatedNote.getMnotetag() + "</span> ");
                        } else {
                            notification.setText("Note ausgeschn./ eingefügt: <span class='bold'>" + updatedNote.getMnotetag() + "</span> ");
                        }
                        this.chatService.sendNotification(notification, members.getMemberid());
                        this.notificationService.addNotification(notification, members.getMemberid());
                    } else {
                        sendControlNotificationsForNote(toSendObjectList, updatedNoteId[0], groupSection.getMsectionid(), finalGroupCanvas1.getMcanvasid(), destinationGroupAccount.getGroupId(), false);
                    }
                }

            }
        } else {
            sendControlNotificationsForNote(toSendObjectList, updatedNoteId[0], groupSection.getMsectionid(), finalGroupCanvas1.getMcanvasid(), destinationGroupAccount.getGroupId(), false);
        }
        GroupNotes processNote = this.groupNotesDAO.getGroupNoteById(updatedNoteId[0]);
        if (processNote != null) {
            processNote.setProcessing(false);
            processNote.setFinished(savedNote.isFinished());
            this.groupNotesDAO.editGroupNote(processNote, sectionId);
            List<GroupAttachments> groupAttachmentsList = this.groupAttachmentsService.getAttachmenByNoteId(updatedNoteId[0]);
            List<Object> objectList = new ArrayList<>();
            objectList.addAll(groupAttachmentsList);
            sendControlNotificationsForNote(objectList, updatedNoteId[0], groupSection.getMsectionid(), groupCanvas.getMcanvasid(), destinationGroupAccount.getGroupId(), false);
        }
        return updatedNoteId[0];
    }

    return 0;
}

Метод, берущий много времени addAttachmentForCopy() :

@Override
public boolean addAttachmentForCopy(GroupAttachments originalFile, GroupNotes groupNotes,
                                    boolean notify, GroupSection groupSection,
                                    GroupCanvas groupCanvas, GroupAccount groupAccount){
    try {
        if (!(originalFile.getSendAttachment() == null)) {
            Person person = this.personService.getCurrentlyAuthenticatedUser();
            Permission permission = this.permissionService.getPermissionForMember(groupAccount.getGroupId());
            boolean uploadAllowed = this.personService.isUploadAllowed(originalFile.getFileSize(), person.getUsername());
            Person attachmentUploader = this.personService.getPersonById(originalFile.getUploaderId());
            if (uploadAllowed) {
                if ((permission.isAddAttachment()) || (person.getId() == groupAccount.getUserId())) {
                    String identifier = new BigInteger(130, random).toString(32);
                    GroupAttachments attachment = new GroupAttachments(originalFile.getFileName(), new Timestamp(System.currentTimeMillis()),
                            this.personService.returnLoggedInUsersEmail(), person.getId(), originalFile.getFileSize(), groupAccount.getGroupId(), identifier,
                            msg + "groupattach/" + groupAccount.getGroupId() + "/", groupSection.getMsectionid(), groupCanvas.getMcanvasid(), groupNotes.getMnoticesid(), originalFile.getMimeType(), "");
                    attachment.setApiUsed("media");
                    if (attachmentUploader != null) {
                        attachment.setUploaderId(attachmentUploader.getId());
                    }
                    attachment.setFullSizePath(identifier);
                    if (originalFile.getFileUploadDate() != null) {
                        attachment.setFileUploadDate(originalFile.getFileUploadDate());
                    } else {
                        attachment.setFileUploadDate(new Timestamp(System.currentTimeMillis()));
                    }
                    final int[] attachId = {0};
                    attachId[0] = this.groupAttachmentsDAO.directAddAttachment(attachment, groupNotes);


                    try {
                        File file = new File(msg + "groupattach/" + groupAccount.getGroupId());
                        boolean creationResult = (file.exists() && file.isDirectory()) || new File(msg + "groupattach/" + groupAccount.getGroupId()).mkdir();
                        if (creationResult) {
                            OutputStream outputStream = new FileOutputStream(new File(msg + "groupattach/" + groupAccount.getGroupId() + "/" + identifier));
                            outputStream.write(originalFile.getSendAttachment());
                            outputStream.close();

                        }
                    } catch (Exception e) {
                     e.printStackTrace();

                    }

                    String extension = originalFile.getFileName().substring(originalFile.getFileName().lastIndexOf(".") + 1, originalFile.getFileName().length()).toLowerCase();

                    try {
                        GroupAttachments attachments = this.groupAttachmentsDAO.getAttachmenById(attachId[0]);
                        if (extension.toLowerCase().equals("zip")) {
                            Path path = Paths.get(msg + "groupattach/" + groupAccount.getGroupId() + "/" + identifier);
                            List<String> fileNames = getListOfFileNamesForZipFile(path);
                            String allNames = "";
                            int counter = 0;
                            for (String str : fileNames) {
                                allNames += str + ":/";
                                if (counter >= 50) {
                                    break;
                                }
                                counter++;
                            }
                            attachments.setFileNames(allNames);
                        }
                        if (extension.toLowerCase().equals("png") || (extension.equals("jpg")) || (extension.equals("jpeg"))) {
                            File outFileForWidth = new File(msg + "groupattach/" + groupAccount.getGroupId() + "/" + identifier);
                            BufferedImage bufferedImage = null;
                            try {
                                bufferedImage = ImageIO.read(outFileForWidth);
                            } catch (IOException e) {
                                e.printStackTrace();

                            }
                            if (bufferedImage != null) {
                                attachments.setWidth(bufferedImage.getWidth());
                                attachments.setHeight(bufferedImage.getHeight());
                                attachments.setNoteid(groupNotes.getMnoticesid());
                                this.groupAttachmentsDAO.updateAttachment(attachments);
                            }
                        }
                    } catch (Exception e) {
                     e.printStackTrace();

                    }

                    try {
                        GroupAttachments attachments = this.groupAttachmentsDAO.getAttachmenById(attachId[0]);
                        if (attachments != null) {
                            try {
                                GroupAttachments originAttachment = this.groupAttachmentsDAO.getAttachmenById(originalFile.getGroupAttachId());
                                if (originAttachment != null) {
                                    File originThumbnail = new File(msg + "thumbnail/" + originAttachment.getGroupId() + "/" + originAttachment.getFileIdentifier());
                                    if (originThumbnail.exists()) {
                                        if (originThumbnail.isFile()) {
                                            byte[] originThumbBytes = FileUtils.readFileToByteArray(originThumbnail);
                                            if (originThumbBytes != null) {
                                                File thumbnail = new File(msg + "thumbnail/" + groupAccount.getGroupId());
                                                boolean result = (thumbnail.exists() && thumbnail.isDirectory()) || new File(msg + "thumbnail/" + groupAccount.getGroupId()).mkdirs();
                                                if (result) {
                                                    OutputStream outputStream = new FileOutputStream(new File(msg + "thumbnail/" + groupAccount.getGroupId() + "/" + identifier));
                                                    outputStream.write(originThumbBytes);
                                                    outputStream.close();
                                                    attachments.setThumbNailAvailable(true);
                                                    this.groupAttachmentsDAO.updateAttachment(attachments);
                                                        addForNoteAndCanvasCopyForLucene(originalFile.getGroupAttachId(), attachId[0], false);

                                                }
                                            }
                                        }
                                    }
                                }

                            } catch (Exception e) {
                               e.printStackTrace();


                            }
                        }


                    } catch (Exception e) {
                       e.printStackTrace();

                    }

                    return true;
                }
            }
        }
    } catch (Exception e) {
        e.printStackTrace();

    }

    return false;
}

Обновление После добавления некоторых таймингов метод, вот что я узнал :

Start of method is 2018-04-11 13:17:24.212
Start of history entry is  2018-04-11 13:17:25.804
start of attachments is  2018-04-11 13:17:39.422
end of attachments is  2018-04-11 13:27:46.432

как вы можете видеть, вложение части заняло 10 минут, чтобы выполнить.



127
1
задан 11 апреля 2018 в 08:04 Источник Поделиться
Комментарии
1 ответ

Вы говорили, что метод addAttachmentForCopy() занимает много времени. Этот метод делает некоторые операции DAO, но и несколько операций чтения файла. Вы уверены, что это доступ к БД, что замедляя его? Я не удивлюсь, если bufferedImage = ImageIO.read(outFileForWidth); потребуется некоторое время. Какой метод getListOfFileNamesForZipFile(path) делаешь?

Не связанных с производительностью, но логика, как

String extension = originalFile.getFileName().substring(originalFile.getFileName().lastIndexOf(".") + 1, originalFile.getFileName().length()).toLowerCase();

очень вероятно, принадлежит в getExtension() способ в GroupAttachments.

Кроме того, упростить такие вещи, как if (!(originalFile.getSendAttachment() == null)) для if (originalFile.getSendAttachment() != null). У вас есть также дополнительные скобки вокруг if ((permission.isAddAttachment()).

4
ответ дан 11 апреля 2018 в 09:04 Источник Поделиться