Подтвердить что ты не робот

Spring Справка по загрузке файла MVC

Я интегрировал spring в приложение и должен повторить загрузку файла из форм. Я знаю, что может предложить spring MVC и что мне нужно сделать, чтобы настроить мои контроллеры для загрузки файлов. Я читал достаточно учебников, чтобы иметь возможность сделать это, но то, что ни одно из этих учебных пособий не объясняет, это правильные/лучшие методы практики о том, как/что делать, чтобы фактически обрабатывать файл после его появления. Ниже приведен код, похожий на код, найденный в spring MVC Docs при обработке загрузки файлов, который можно найти на сайте Spring Загрузка файла MVC

В приведенном ниже примере вы можете увидеть, что они показывают все, что нужно сделать, чтобы получить файл, но они просто говорят Сделайте что-то с bean

Я проверил множество обучающих программ, и все они, похоже, доводят меня до этого момента, но то, что я действительно хочу знать, - лучший способ обработать файл. Как только у меня есть файл в этот момент, как лучше всего сохранить этот файл в каталоге на сервере? Может кто-нибудь, пожалуйста, помогите мне с этим? Благодаря

public class FileUploadController extends SimpleFormController {

protected ModelAndView onSubmit(
    HttpServletRequest request,
    HttpServletResponse response,
    Object command,
    BindException errors) throws ServletException, IOException {

     // cast the bean
    FileUploadBean bean = (FileUploadBean) command;

     let see if there content there
    byte[] file = bean.getFile();
    if (file == null) {
         // hmm, that strange, the user did not upload anything
    }

    //do something with the bean 
    return super.onSubmit(request, response, command, errors);
}
4b9b3361

ОТВЕТЫ

Ответ 1

Это то, что я предпочитаю при загрузке. Я думаю, что позволить spring обрабатывать сохранение файлов - это лучший способ. spring выполняет его с помощью функции MultipartFile.transferTo(File dest).

import java.io.File;
import java.io.IOException;

import javax.servlet.http.HttpServletResponse;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.multipart.MultipartFile;

@Controller
@RequestMapping("/upload")
public class UploadController {

    @ResponseBody
    @RequestMapping(value = "/save")
    public String handleUpload(
            @RequestParam(value = "file", required = false) MultipartFile multipartFile,
            HttpServletResponse httpServletResponse) {

        String orgName = multipartFile.getOriginalFilename();

        String filePath = "/my_uploads/" + orgName;
        File dest = new File(filePath);
        try {
            multipartFile.transferTo(dest);
        } catch (IllegalStateException e) {
            e.printStackTrace();
            return "File uploaded failed:" + orgName;
        } catch (IOException e) {
            e.printStackTrace();
            return "File uploaded failed:" + orgName;
        }
        return "File uploaded:" + orgName;
    }
}

Ответ 2

но то, что ни один из этих учебных пособий не объясняет, - это правильные/лучшие методы практики о том, как/что делать, чтобы фактически обрабатывать файл, когда он у вас есть.

Лучшая практика зависит от того, что вы пытаетесь сделать. Обычно я использую AOP для последующей загрузки загруженного файла. Затем вы можете использовать FileCopyUtils для хранения загруженного файла

@Autowired
@Qualifier("commandRepository")
private AbstractRepository<Command, Integer> commandRepository;

protected ModelAndView onSubmit(...) throws ServletException, IOException {
    commandRepository.add(command);
}

AOP описывается следующим образом

@Aspect
public class UploadedFileAspect {

    @After("execution(* br.com.ar.CommandRepository*.add(..))")
    public void storeUploadedFile(JoinPoint joinPoint) {
        Command command = (Command) joinPoint.getArgs()[0];

        byte[] fileAsByte = command.getFile();
        if (fileAsByte != null) {
            try {
                FileCopyUtils.copy(fileAsByte, new File("<SET_UP_TARGET_FILE_RIGHT_HERE>"));
            } catch (IOException e) {
                /**
                  * log errors
                  */
            }
        }

    }

Не забудьте включить аспект (при необходимости обновите схему до Spring 3.0). Поместите путь к классам aspectjrt.jar и aspectjweaver.jar(<SPRING_HOME > /lib/aspectj) и

<beans xmlns="http://www.springframework.org/schema/beans"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xmlns:aop="http://www.springframework.org/schema/aop"
      xsi:schemaLocation="http://www.springframework.org/schema/beans
                          http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
                          http://www.springframework.org/schema/aop
                          http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
    <aop:aspectj-autoproxy />
    <bean class="br.com.ar.aop.UploadedFileAspect"/>

Ответ 3

Используйте следующий класс контроллера для обработки загрузки файла.

@Controller
public class FileUploadController {

  @Autowired
  private FileUploadService uploadService;

  @RequestMapping(value = "/fileUploader", method = RequestMethod.GET)
  public String home() {
    return "fileUploader";
  }

  @RequestMapping(value = "/upload", method = RequestMethod.POST)
  public @ResponseBody List<UploadedFile> upload(MultipartHttpServletRequest request, HttpServletResponse response) throws IOException {

    // Getting uploaded files from the request object
    Map<String, MultipartFile> fileMap = request.getFileMap();

    // Maintain a list to send back the files info. to the client side
    List<UploadedFile> uploadedFiles = new ArrayList<UploadedFile>();

    // Iterate through the map
    for (MultipartFile multipartFile : fileMap.values()) {

      // Save the file to local disk
      saveFileToLocalDisk(multipartFile);

      UploadedFile fileInfo = getUploadedFileInfo(multipartFile);

      // Save the file info to database
      fileInfo = saveFileToDatabase(fileInfo);

      // adding the file info to the list
      uploadedFiles.add(fileInfo);
    }

    return uploadedFiles;
  }

  @RequestMapping(value = {"/listFiles"})
  public String listBooks(Map<String, Object> map) {

    map.put("fileList", uploadService.listFiles());

    return "listFiles";
  }

  @RequestMapping(value = "/getdata/{fileId}", method = RequestMethod.GET)
  public void getFile(HttpServletResponse response, @PathVariable Long fileId) {

    UploadedFile dataFile = uploadService.getFile(fileId);

    File file = new File(dataFile.getLocation(), dataFile.getName());

    try {
      response.setContentType(dataFile.getType());
      response.setHeader("Content-disposition", "attachment; filename=\"" + dataFile.getName() + "\"");

      FileCopyUtils.copy(FileUtils.readFileToByteArray(file), response.getOutputStream());


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


  private void saveFileToLocalDisk(MultipartFile multipartFile) throws IOException, FileNotFoundException {

    String outputFileName = getOutputFilename(multipartFile);

    FileCopyUtils.copy(multipartFile.getBytes(), new FileOutputStream(outputFileName));
  }

  private UploadedFile saveFileToDatabase(UploadedFile uploadedFile) {
    return uploadService.saveFile(uploadedFile);
  }

  private String getOutputFilename(MultipartFile multipartFile) {
    return getDestinationLocation() + multipartFile.getOriginalFilename();
  }

  private UploadedFile getUploadedFileInfo(MultipartFile multipartFile) throws IOException {

    UploadedFile fileInfo = new UploadedFile();
    fileInfo.setName(multipartFile.getOriginalFilename());
    fileInfo.setSize(multipartFile.getSize());
    fileInfo.setType(multipartFile.getContentType());
    fileInfo.setLocation(getDestinationLocation());

    return fileInfo;
  }

  private String getDestinationLocation() {
    return "Drive:/uploaded-files/";
  }
}