Spring MVC File Upload Aiuto

Question

Ho integrato Spring in un'applicazione e devo ripetere il caricamento di un file dai moduli. Sono a conoscenza di ciò che Spring MVC ha da offrire e cosa devo fare per configurare i miei controller per poter caricare file. Ho letto abbastanza tutorial per essere in grado di farlo, ma quello che nessuno di questi tutorial spiega è corretto/metodi di pratica migliore su come/che cosa deve essere fatto per gestire effettivamente il file una volta che ce l'hai. Di seguito è riportato un codice simile al codice che si trova sulla Spring MVC Documenti sulla gestione upload di file che può essere trovato alla
Spring MVC File Upload

Nell'esempio sottostante si può vedere che vi mostrano tutto da fare per ottenere il file, ma basta dire fare qualcosa con il bean

Ho controllato molti tutorial e tutti sembrano portarmi a questo punto, ma quello che voglio veramente sapere è il modo migliore per gestire il file. Una volta che ho un file a questo punto, qual è il modo migliore per salvare questo file in una directory su un server? Qualcuno può aiutarmi per favore con questo? Grazie

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's see if there's content there 
    byte[] file = bean.getFile(); 
    if (file == null) { 
     // hmm, that's strange, the user did not upload anything 
    } 

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

Answer 1

Questo è quello che preferisco rendendo upload. Penso che lasciare che la primavera gestisca il salvataggio dei file, è il modo migliore. Spring lo fa con la sua funzione 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; 
    } 
} 

Answer 2

ma che nessuno di questi tutorial spiega è corretto/i metodi migliori pratiche su come/cosa si deve fare per gestire realmente il file una volta che lo avete

La pratica migliore dipende da cosa stai cercando di fare. Di solito uso alcuni AOP per post-processare il file caricato. Quindi è possibile utilizzare FileCopyUtils per memorizzare il file caricato

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

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

AOP è descritto come segue

@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 
        */ 
      } 
     } 

    } 

Non dimenticare di abilitazione aspetto (schema di aggiornamento alla primavera 3.0 se necessario) Mettere sul aspectjrt.jar classpath e aspectjweaver.jar (<SPRING_HOME>/lib/aspectj) e

<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"/> 

Answer 3

Utilizzare la classe del controller sottostante per l'elaborazione del caricamento del file.

@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/"; 
    } 
}