如何清除上传组件的内存缓冲程序

Question

第一个计时器在这里：我有一个上传组件，该组件会拍摄图像并在布局中显示。保存按钮触发器将图像保存到DB并正常工作。

这是一个问题：对于下一个记录，在Trrigering保存方法上，如果在上传组件中不添加图像，则再次保存上一个图像。（我猜MemoryBuffer仍然具有该图像）。因此，我的问题是，如何为下一个记录清除内存缓冲区。另外，我想知道是否可以检索ImageContainer中显示的图像以将其保存到图像变量中。

```

    public class EmployeeForm extends FormLayout {
        
        Image image;
        Button save = new Button("Save");
        Button delete = new Button("Delete");
        Button close = new Button("Close");
        MemoryBuffer buffer= new MemoryBuffer();
        Upload upload= new Upload(buffer); 
        VerticalLayout imageContainer=new VerticalLayout();
        BufferedImage inputImageoriginal=null;
        public EmployeeForm(List<Office> offices, List<Cell> cells, DbService dbservice) {
            binder.bindInstanceFields(this);
            office.setItems(dbservice.findOfficesBydistrict());
            cell.setItems(dbservice.findCellsBydistrict());
            office.setItemLabelGenerator(Office::getOfficeName);
            cell.setItemLabelGenerator(Cell::getCellName);
            add(firstName, lastName, designation, office, cell, createUpload(), createButtonsLayout(), imageContainer);
        }
    
        private Component createUpload() {
            upload.setMaxFiles(1);
            upload.setMaxFileSize(100000);
            upload.setUploadButton(new Button ("Upload Photo"));
            upload.setDropLabel(new Label("Drop Photo"));
            upload.setAcceptedFileTypes("image/tiff", "image/jpeg", "image/jpg");
            upload.addFileRejectedListener(e -> notify.show("Invalid File: Please select only image files less than 100kb",3000, Position.TOP_END));
            upload.addSucceededListener(event -> showPicture());
            return upload;
        }
    
        public void showPicture() {
            try {
                if (imageContainer != null) {
                    remove(imageContainer);
                }
                StreamResource resource = new StreamResource("inputimage",
                        () -> new ByteArrayInputStream(getImageAsByteArray()));
                image = new Image(resource, "No Photo to display");
                imageContainer = new VerticalLayout();
                imageContainer.setWidth("200px");
                imageContainer.setHeight("200px");
                imageContainer.getStyle().set("overflow-x", "auto");
                imageContainer.add(image);
                add(imageContainer);
                //imageContainer.get
            } catch (Exception e) {
                e.printStackTrace();
                notify.show("Error" + e);
            }
        }
        
        public void clearBuffer() {
            try {
                upload.clearFileList();
                
            } catch (Exception e) {
                // TODO: handle exception
            }
        }
    
        private byte[] getImageAsByteArray() {
            try {
                
                inputImageoriginal= ImageIO.read(buffer.getInputStream());
                if (inputImageoriginal == null) {
                    return null;
                } else {
                    BufferedImage inputImage = resizeImage(inputImageoriginal);
                    ByteArrayOutputStream pngContent = new ByteArrayOutputStream();
                    ImageIO.write(inputImage, "jpg", pngContent);
                    InputStream is = new ByteArrayInputStream(pngContent.toByteArray());
                    return IOUtils.toByteArray(is);
                }
            } catch (IOException e) {
                e.printStackTrace();
                return null;
            }
        }
        
        
        BufferedImage resizeImage(BufferedImage originalImage) throws IOException {
            BufferedImage resizedImage = new BufferedImage(150, 150, BufferedImage.TYPE_INT_RGB);
            Graphics2D graphics2D = resizedImage.createGraphics();
            graphics2D.drawImage(originalImage, 0, 0, 150, 150, null);
            graphics2D.dispose();
            return resizedImage;
        }
    
        private Component createButtonsLayout() {
            // TODO Auto-generated method stub
            save.setWidthFull();
            delete.setWidthFull();
            close.setWidthFull();
            save.addThemeVariants(ButtonVariant.LUMO_PRIMARY);
            save.addClickShortcut(Key.ENTER);
            save.addClickListener(event -> validatandSave());
            delete.addClickListener(event -> fireEvent(new DeleteEvent(this, employee)));
            close.addClickListener(event -> fireEvent(new CloseEvent(this)));
            return new HorizontalLayout(save, delete, close);
        }
    
        private void validatandSave() {
            try {
                
                binder.writeBean(employee);
                if (getImageAsByteArray() != null) {
                    employee.setPicture(getImageAsByteArray());
                }
    
                fireEvent(new SaveEvent(this, employee));
                
            } catch (ValidationException e) {
                // TODO Auto-generated catch block
                Notification notification = Notification.show("Please Enter All Required Fields", 3000,
                        Position.TOP_CENTER);
            }
        }
    
        public void setEmployee(Employee employee) {
            this.employee = employee;
            binder.readBean(employee);
        }
    
    ///Operation Save/Delete Events
    
        public static abstract class EmployeeFormEvent extends ComponentEvent<EmployeeForm> {
            private Employee employee;
    
            protected EmployeeFormEvent(EmployeeForm source, Employee employee) {
                super(source, false);
                this.employee = employee;
            }
    
            public Employee getEmployee() {
                return employee;
            }
        }
    
        public static class SaveEvent extends EmployeeFormEvent {
            SaveEvent(EmployeeForm source, Employee employee) {
                super(source, employee);
            }
        }
    
        public static class DeleteEvent extends EmployeeFormEvent {
            DeleteEvent(EmployeeForm source, Employee employee) {
                super(source, employee);
            }
    
        }
    
        public static class CloseEvent extends EmployeeFormEvent {
            CloseEvent(EmployeeForm source) {
                super(source, null);
            }
        }
    
        public <T extends ComponentEvent<?>> Registration addListener(Class<T> eventType,
                ComponentEventListener<T> listener) {
            return getEventBus().addListener(eventType, listener);
        }
    
    
        public void addImage(Image image2) {
            // TODO Auto-generated method stub
            // remove(imageContainer);
            if(imageContainer!=null) {
                imageContainer.removeAll();
            }
            imageContainer.add(image2);
            //add(imageContainer);
        
        }
    }

```

Answer 1

查看MemoryBuffer的实现，您必须将其扔掉并设置一个新的，例如clearBuffer（）方法。

buffer = new MemoryBuffer();
upload.setReceiver(buffer);