Si necesita cargar archivos en los servidores, está cargando nuestros archivos locales al servidor de recursos. La mejor manera es subirlos a través de FTP. Esto se carga en combinación con SpringMVC+FTP. Primero debemos comprender cómo configurar SpringMVC, luego configurar FTP y finalmente cargar el archivo en combinación con MultipartFile.
SpringMVC La carga requiere varios paquetes de jares clave, los paquetes de resorte y asociados pueden ser configurados por usted mismo. Aquí explicamos principalmente los paquetes de jarra clave
1: Spring-Web-3.2.9.Release.Jar (el paquete de primavera clave de Key Jar, puede elegir la versión usted mismo)
2: Commons-io-2.2.Jar (algunos paquetes de herramientas utilizados para manejar IO en el proyecto)
Archivo de configuración
SpringMVC utiliza multipartfile para cargar archivos, por lo que necesitamos configurar MultiprArtResolver para manejar los archivos en el formulario
<
Los atributos se explican en detalle:
DefaultEncoding configura el formato de codificación de la solicitud, ISO-8859-1 predeterminado
La unidad máxima del archivo de configuración maxuploadsize, en bytes
MaxInMemorySize configura el caché de archivos cargados, en bytes
La propiedad resolvelazily está habilitada para retrasar la resolución de archivos para que las excepciones de tamaño de archivo puedan ser capturadas en SuboLoadAction
Configuración de la página
Agregar enctype = "multipart/formy-data" a la forma de la página
<Form ID = "" name = "" Method = "Post" Action = "" Enctype = "multipart/formy-data">
Establezca enctype = "multipart/formy-data" en la etiqueta de formulario para garantizar la codificación correcta del archivo cargado anónimo.
Es la codificación mime de la forma. Por defecto, este formato de codificación es Application/X-WWW-Form-URLEncoded, que no se puede utilizar para la carga de archivos; Solo mediante el uso de datos multipart/formulario se puede pasar completamente los datos del archivo y se realizan las siguientes operaciones. Enctype = "multipart/formy-data" es cargar datos binarios. El valor de entrada en el formulario se pasa de forma de 2 dígitos, por lo que la solicitud no puede obtener el valor.
Escribir la clase de control de carga
Escriba un método de carga, y no hay resultado devuelto aquí. Si necesita saltar a la página o devolver otros valores, puede cambiar Void a String, Maps <String, Object> y otros valores, y luego volver para volver para devolver el resultado.
/** * cargar * @param request * @return */@ResponseBody @RequestMapping (value = "/upload", método = {requestMethod.get, requestmethod.post}) public void upload (httttpServletRequest) {Solicitud de multipThtttTpSeBletRequest multiplEctExest = (multiparthttttRequest) solicitud). Archivo multipartFile = multiparTruCeT.getFile ("file"); // El archivo es el nombre de nombre de la página de entrada String basepath = "ruta de archivo" intente {multipartResolver resolver = new CommonsMultIParTresolver (request.getSession (). GetServletContext ()); if (resolver.ismultipart (request)) {string fileSoredPath = "ruta de carpeta"; // Nombre de archivo generado aleatorio String RandomName = StringUtil.getRandomFileName (); String uploadFileName = file.getOriginalFileName (); if (stringUtils.isNotBlank (uploadFileName)) {// Intercepta el nombre del formato de archivo String sufix = uploadFileName.substring (uploadFileName.IndexOf (".")); // Vuelva a ensamblar la cadena del nombre del archivo newFileName = randomName + sufix; String SavePath = BasePath + "/" + NewFileName; Archivo saveFile = nuevo archivo (savePath); Archivo parentFile = saveFile.getParentFile (); if (saveFile.exists ()) {saveFile.Delete (); } else {if (! parentFile.exists ()) {parentFile.mkDirs (); }} // Copie el archivo en la ruta especificada fileUtil.CopyInputStreamToFile (file.getInputStream (), saveFile); // cargar el archivo en el servidor ftpClientUtil.upload (saveFile, filestoredPath); }}} Catch (Exception e) {E.PrintStackTrace (); }} Herramienta de carga del cliente FTP
paquete com.yuananding.common.util; import java.io.file; import java.io.fileInputStream; import java.io.fileOutputStream; import java.io.ioException; import java.io.inputstream; import java.io.outputstream; import java.net.socketException; import java.util.hashmap; import java.util.map; import java.util.properties; importar org.apache.commons.lang.stringutils; importar org.apache.commons.net.ftp.ftp; importar org.apache.commons.net.ftp.ftpclient; importar org.apache.commons.net.ftp.ftpreply; importar org.slf4j.logger; importar org.slf4j.loggerFactory; / *** FTP Herramientas del cliente*/ Public Class ftpClientUtil {/ *** log*/ private static final logger logger = loggerFactory.getLogger (ftpClientUtil.class); / ** * Configuración del servidor FTP-Tecla de IP, valor es un tipo de cadena */ public static final String server_ip = "server_ip"; / ** * Configuración del servidor FTP-Key Port, Value es un tipo de entero */ public static final String server_port = "server_port"; / ** * Configuración del servidor FTP: la clave de inicio de sesión anónima, el valor es un tipo de boolean */ public static final String is_anonymous = "is_anonymous"; / ** * Nombre de usuario del inicio de sesión anónimo */ public static final String anónimo_user_name = "Anónimo"; / ** * Contraseña del inicio de sesión anónimo */ public static final String anyonymous_password = ""; / ** * Configuración del servidor FTP: log en nombre de usuario, el valor es un tipo de cadena */ public static final String user_name = "user_name"; / ** * Configuración del servidor FTP: registrar en contraseña, el valor es un tipo de cadena */ public static final string contraseña = "contraseña"; / ** * Configuración del servidor FTP: la tecla Pasv, el valor es un tipo de boolean */ public static final String is_pasv = "is_pasv"; /** * Configuración del servidor FTP: la clave del directorio de trabajo, el valor es un tipo de cadena al iniciar sesión, el directorio actual * es el directorio de inicio del usuario, el Directorio de trabajo debe establecerse en función de él. Además, el Directory Working debe * existir, no se puede crear automáticamente. Si no existe, el archivo se cargará en el directorio de inicio del usuario. Si * no se asigna, "/" se usa. */ public static final String working_directory = "working_directory"; Public Static Map <String, Object> ServerCfg = new HashMap <String, Object> (); Propiedades de propiedades estáticas; static {logger.info ("Comience a cargar el archivo ftp.properties!"); prop = new Properties (); Pruebe {inputStream fps = ftpClientUtil.class.getResourceASStream ("/ftp.properties"); prop.load (fps); fps.close (); } catch (Exception e) {logger.error ("La excepción lee el archivo ftp.properties!", e); } servercfg.put (ftpClientUtil.server_ip, valores ("server_ip")); servercfg.put (ftpClientUtil.server_port, integer.parseInt (valores ("server_port"))); servercfg.put (ftpClientUtil.user_name, valores ("user_name")); servercfg.put (ftpClientUtil.password, valores ("contraseña")); Logger.info (String.ValueOf (serverCfg)); } /*** Sube un archivo al servidor FTP. * * @param serverCfg : FTP server configuration * @param filePathToUpload : path of the file to upload * @param fileStoredName : the name to give the remote stored file, null, "" and other blank word will be replaced * by the file name to upload * @throws IOException * @throws SocketException */ public static final void upload(Map<String, Object> serverCfg, String FilePathToUpload, String FileStoredName) lanza SocketException, ioException {upload (serverCfg, nuevo archivo (filePathToUpload), fileStoredName); } /*** Sube un archivo al servidor FTP. * * @param serverCfg : FTP server configuration * @param fileToUpload : file to upload * @param fileStoredName : the name to give the remote stored file, null, "" and other blank word will be replaced * by the file name to upload * @throws IOException * @throws SocketException */ public static final void upload(Map<String, Object> serverCfg, File fileToUpload, String fileStoredName) lanza SocketException, ioException {if (! FiletoUpload.Exists ()) {throLe New IlegalArGumentException ("El archivo para cargar no existe:" + filetoupload.getabsolutePath ()); } if (! filetoUpload.Isfile ()) {tire nuevo IlegalArgumentException ("El archivo para cargar no es un archivo:" + filetoUpload.getabsolutePath ()); } if (stringUtils.isblank ((string) servercfg.get (server_ip))) {lanzar nueva ilegalArGumentException ("Server_ip debe estar contenida en la configuración del servidor FTP"); } transferfile (true, servercfg, filetoUpload, fileStoredName, null, null); } / ** * Descargue un archivo desde el servidor ftp * * @param servercfg: configuración del servidor ftp * @param filenamETODOWnownload: el nombre del archivo a descargar * @param filestoredPath: ruta almacenada de la ruta almacenada del archivo descargado en local * @throws socketException * @throws ioexception * / public estatic final Void descargar (map <string, objeto> servercfg, stockeDoodload, string fileNodeDOWnowlownlownownlownown. FilestoredPath) lanza SocketException, IOException {if (StringUtils.isblank (FileNAMETODOWNLOAD)) {Throw New IlegalArGumentException ("El nombre del archivo para descargar no puede estar en blanco"); } if (StringUtils.isblank (FilestoredPath)) {Throw New IlegalArgumentException ("La ruta almacenada del archivo descargado en el local no puede estar en blanco"); } if (stringUtils.isblank ((string) servercfg.get (server_ip))) {lanzar nueva ilegalArGumentException ("Server_ip debe estar contenida en la configuración del servidor FTP"); } transferfile (false, servercfg, null, null, fileNAMETODOWNLOAD, FileStoredPath); } private static final void transferfile (boolean isUpload, map <string, object> servercfg, file fileToUpload, string serverfileSeToredName, string fileNAMETODOWNLOOK, string localFilEndedPath) lanza SocketException, ioException {String host = (String) ServerCfg.get (Server_IP); Integer Port = (Integer) ServerCfg.get (server_port); Boolean isanonymous = (boolean) servercfg.get (is_anonymous); String UserName = (String) ServerCfg.get (user_name); String Password = (String) ServerCfg.get (contraseña); Boolean ispasv = (boolean) servercfg.get (is_pasv); String WorkingDirectory = (String) ServerCfg.get (Working_Directory); FtpClient ftpClient = new ftpClient (); InputStream filein = null; OutputStream FileOut = NULL; Pruebe {if (port == null) {logger.debug ("conectarse al servidor FTP en" + host + ":" + ftp.default_port); ftpClient.connect (host); } else {logger.debug ("conectar al servidor FTP en" + host + ":" + puerto); ftpclient.connect (host, puerto); } int respuesta = ftpClient.getReplyCode (); if (! ftPreply.IspositiveCompletion (respuesta)) {logger.error ("El servidor FTP rechaza la conexión"); devolver; } if (isanonymous! = null && isanonymous) {username = anyonymous_user_name; contraseña = anónimo_password; } Logger.debug ("Iniciar sesión FTP Server con Username =" + UserName + ", Password =" + Password); if (! ftpclient.login (userName, contraseña)) {logger.error ("no iniciar sesión en el servidor FTP con username =" + username + ", contraseña =" + contraseña); ftpClient.logout (); devolver; } // Aquí usaremos el modo binario como tipo de archivo de transferencia, // no es compatible con el modo ASCII. Logger.debug ("Establezca el tipo de archivo, que es cargar, a binario"); ftpclient.setFileType (ftp.binary_file_type); if (ispasv! = null && ispasv) {logger.debug ("use el modo Pasv para transferir el archivo."); ftpClient.EnterLocalPassivEmode (); } else {logger.debug ("Use el modo activo para transferir el archivo"); ftpClient.ENTERLOCALACTIVEMODE (); } if (StringUtils.isblank (WorkingDirectory)) {WorkingDirectory = "/"; } Logger.debug ("Cambiar el directorio de trabajo actual a" + WorkingDirectory); ChangeWorkingDirectory (FTPClient, WorkingDirectory); if (isupload) {// if (stringUtils.isblank (serverFilEndoredName)) {serverFilEndedName = filetoUpload.getName (); } filein = new FileInputStream (filetoUpload); Logger.debug ("Sobre el archivo:" + filetoUpload.getabsolutePath () + "al servidor FTP con el nombre:" + ServerFilEndoredName); if (! ftpClient.storeFile (ServerFilEndoredName, fileIn)) {logger.error ("no cargar archivo," + ftpclient.getRepplyString ()); } else {logger.debug ("éxito para cargar archivo."); }} else {// Descargar // Asegúrese de que el directorio de archivos exista archivo filestored = nuevo archivo (localfilestoredPath); if (! fileStored.getParentFile (). Exists ()) {filestored.getParentFile (). mkdirs (); } fileout = new FileOutputStream (Filestored); Logger.debug ("Descargar archivo:" + FileNAMETODOWNLOAD + "del servidor FTP al local:" + LocalFilEdoredPath); if (! ftpclient.retrieveFile (fileNAMETODOWNLOAD, fileOut)) {logger.error ("no descargar archivo," + ftpClient.getRreplyString ()); } else {logger.debug ("éxito para descargar archivo"); }} ftpClient.Noop (); ftpClient.logout (); } Finalmente {if (ftpClient.isConnected ()) {try {ftpClient.disconnect (); } catch (ioException f) {}} if (filein! = null) {try {fileIn.close (); } catch (ioException e) {}} if (fileout! = null) {try {fileout.close (); } catch (ioException e) {}}} privado estático final Boolean ChangeWorkingDirectory (ftpClient ftpClient, string workingDirectory) lanza ioexception {if (! ftpClient.changeWorkingDirectory (workingDirectory)) {string [] rutas = workingDirectory.split ("/"); for (int i = 0; i <raths.length; i ++) {if (! "". Equals (ruta [i])) {if (! ftpClient.ChangeWorkingDirectory (rutas [i])) {ftpClient.MakedIrectory (rutas [i]); ftpClient.ChangeWorkingDirectory (rutas [i]); }}} return true; } public static static final void upload (map <string, object> servercfg, string filepathToUpload, string fileStoredPath, string fileStoredName) lanza SocketException, ioException {upload (serverCfg, nuevo archivo (filePathToUpload), fileStoredPath, filestoredName); } public static final void upload (map <string, object> servercfg, file filetoUpload, string fileStoredPath, string fileStoredName) lanza SocketException, ioexception {if (fileSoredPath! = null &&! "". Equals (FilestoredPath))) } cargar (serverCfg, filetoUpload, fileStoredName); } public static final void upload (string filepathToUpload, string filestoredPath) arroja socketException, ioException {ifoad (serverCfg, filepathToUpload, filestoredPath, ""); } public static final void upload (archivo filetoUpload, string filestoredPath) arroja SocketException, ioException {upload (serverCfg, filetoUpload, fileStoredPath, ""); } public static String Values (tecla de cadena) {String value = prop.getProperty (clave); if (value! = null) {value de retorno; } else {return null; }}} ftp.properties
#Server Direcciones server_ip = 192.168.1.1 #Server Port Server_port = 21 #ACCount Nombre user_name = userftp #Password #Password = Passwordftp
Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.