SpringMVC使用MultipartFile文件上传配置,多文件上传
Java利用MultipartFile实现上传多份文件的代码
Java利⽤MultipartFile实现上传多份⽂件的代码配置⽂件<!-- ⽂件上传 --><bean id="multipartResolver" class="monsMultipartResolver"><property name="defaultEncoding" value="utf-8"></property><property name="maxUploadSize" value="10485760000"></property><property name="maxInMemorySize" value="40960"></property></bean>form表单<form action="xxx.do" method="post" multiple="multiple""><input type="file" id="file" name="filename" multiple="multiple" value=""><input type="file" id="file" name="filename" multiple="multiple" value=""><input type="submit" value="上传"></form>java后台接受⽰例@RequestMapping("xxx")public String fileImgSave(@RequestParam("filename") MultipartFile[] files,HttpServletRequest request){//保存⽂件的路径String realPath = request.getSession().getServletContext().getRealPath("/imgssss");File path = new File(realPath);if(!path.exists()){path.mkdirs();}//判断file数组不能为空并且长度⼤于0if(files != null && files.length > 0){//循环获取file数组中得⽂件for(int i = 0;i < files.length;i++){MultipartFile file = files[i];//保存⽂件if (!file.isEmpty()){try {//转存⽂件 file.getOriginalFilename();⽂件原名称包括后缀名file.transferTo(new File(realPath+"/img"+i+".png"));} catch (IOException e) {e.printStackTrace();}}}}return "ok";}MultipartFile常⽤⽅法记录⽂件类型值 getContentType()⽂件原始名称包括后缀名 getOriginalFilename()表单中⽂件组件对应name值 getName()保存到⼀个⽬标⽂件中 transferTo()⽂件是否为空 isEmpty()⽂件⼤⼩单位为k getSize()总结以上所述是⼩编给⼤家介绍的Java利⽤MultipartFile实现上传多份⽂件的代码,希望对⼤家有所帮助，如果⼤家有任何疑问请给我留⾔，⼩编会及时回复⼤家的。
springmvc文件上传
一、单个文件上传，除了常规引用jar包外，还需要在spring配置文件中加上如下的配置：第一步：<!-- 支持文件上传 --><bean id="multipartResolver"class="monsMultipart Resolver"><property name="defaultEncoding"value="utf-8"></property><!-- 上传文件的最大值 --><property name="maxUploadSize"value="10485760000"></property><!-- 缓存大小 --><property name="maxInMemorySize"value="40960"></property> </bean>第二步：Upload.jsp<form action="udLoad/upload.do"method="post"enctype="multipart/form-data">选择:<input type="file"name="myfile"id="myfile"><br/><input type="submit"value="提交"></form>第三步：controller@RequestMapping("/upload")public String upload(Model model, HttpServletRequest request, //此时传的是参数，不是对象@RequestParam(value = "myfile") MultipartFile multipartFile)throws IOException {System.out.println("进入该方法");// 获取上传的文件保存的路径String path =request.getSession().getServletContext().getRealPath("upload");// 获取上传的文件的名称String filename = multipartFile.getOriginalFilename();//创建文件夹uploadFile targetFile = new File(path, filename);//判断文件夹是否已经存在，如果已经存在了重新建if (!targetFile.exists()) {targetFile.mkdirs();}multipartFile.transferTo(targetFile);model.addAttribute("fileUrl", request.getContextPath() +"/upload/" + filename);return"voteCount/result";}。
spring mvc 多文件上传
1.后台/* =============文件上传================ */MultipartHttpServletRequestmultipartRequest = (MultipartHttpServletRequest) request;String sep =System.getProperty("file.separator");Map files = multipartRequest.getFileMap(); Iterator fileNames =multipartRequest.getFileNames();StringBuffer sb = new StringBuffer();boolean flag = false;String fileDir = “E:/upload”+ sep + System.currentTimeMillis();// 存放文件文件夹名称for (; fileNames.hasNext();) {String filename = (String)fileNames.next();CommonsMultipartFile file = (CommonsMultipartFile) files.get(filename);byte[] bytes = file.getBytes();if (bytes.length != 0) {// 说明申请有附件if (!flag) {File dirPath = new File(fileDir);if (!dirPath.exists()) {flag = dirPath.mkdirs();}}String fileTrueName =file.getOriginalFilename();File uploadedFile = new File(fileDir + sep + fileTrueName);FileCopyUtils.copy(bytes, uploadedFile);sb.append(fileTrueName).append(","); }}2.页面:代码: <p><input type="file"size="50"name="file0"/></p><%--多个文件表但name="file"不能相同，否则文件会被覆盖 --%><p><inputtype="file"size="50"name="file1"/></p>3.中间的配置就不写了,spring mvc基础可以同时上传多文件,写的不是很详细随笔一纪录,可留言共同讨论。
SpringMVC-文件上传和下载
SpringMVC-⽂件上传和下载⽂件上传和下载⽬录1. ⽂件上传1. 前端设计前端表单要求：为了能上传⽂件，必须将表单的method设置为POST，并将enctype设置为multipart/form-data。
只有在这样的情况下，浏览器才会把⽤户选择的⽂件以⼆进制数据发送给服务器；<%--Created by IntelliJ IDEA.User: WangDate: 2020/9/11Time: 16:48To change this template use File | Settings | File Templates.--%><%@ page contentType="text/html;charset=UTF-8" language="java" %><html><head><title>$Title$</title></head><body><form action="${pageContext.request.contextPath}/upload" enctype="multipart/form-data" method="post"><input type="file" name="file"><input type="submit" value="upload"></form></body></html>2. 导⼊依赖commons-fileupload<dependencies><!--⽂件上传--><dependency><groupId>commons-fileupload</groupId><artifactId>commons-fileupload</artifactId><version>1.4</version></dependency><!--servlet-api导⼊⾼版本的--><dependency><groupId>javax.servlet</groupId><artifactId>javax.servlet-api</artifactId><version>4.0.1</version></dependency></dependencies>3. 配置Spring<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:mvc="/schema/mvc"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans.xsd/schema/contexthttps:///schema/context/spring-context.xsd/schema/mvchttps:///schema/mvc/spring-mvc.xsd"><context:component-scan base-package="com.wang.controller"/><mvc:annotation-driven/><mvc:default-servlet-handler/><bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"id="internalResourceViewResolver"><property name="prefix" value="/WEB-INF/jsp/"/><property name="suffix" value=".jsp"/></bean><mvc:annotation-driven><mvc:message-converters register-defaults="true"><bean class="org.springframework.http.converter.StringHttpMessageConverter"><constructor-arg value="UTF-8"/></bean><bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"><property name="objectMapper"><bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean"><property name="failOnEmptyBeans" value="false"/></bean></property></bean></mvc:message-converters></mvc:annotation-driven><!--⽂件上传配置--><bean id="multipartResolver" class="monsMultipartResolver"><!-- 请求的编码格式, 必须和jsp的pageEncoding属性⼀致, 以便正确读取表单的内容, 默认为ISO-8859-1 --><property name="defaultEncoding" value="utf-8"/><!-- 上传⽂件⼤⼩上限, 单位为字节 (10485760 = 10M) --><property name="maxUploadSize" value="10485760"/><property name="maxInMemorySize" value="40960"/></bean></beans>注意这个bena的id必须为：multipartResolver ，否则上传⽂件会报400的错误！4. 编写controller有两种上传的⽅式1. getOriginalFilename⽅法package com.wang.controller;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RequestParam;import org.springframework.web.bind.annotation.RestController;import monsMultipartFile;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import java.io.*;import .URLEncoder;@RestControllerpublic class FileController {//@RequestParam("file") 将name=file控件得到的⽂件封装成CommonsMultipartFile 对象//批量上传CommonsMultipartFile则为数组即可@RequestMapping("/upload")public String fileUpload(@RequestParam("file") CommonsMultipartFile file, HttpServletRequest request) throws IOException { //获取⽂件名 : file.getOriginalFilename();String uploadFileName = file.getOriginalFilename();//如果⽂件名为空，直接回到⾸页！if ("".equals(uploadFileName)) {return "redirect:/index.jsp";}System.out.println("上传⽂件名 : " + uploadFileName);//上传路径保存设置String path = request.getServletContext().getRealPath("/upload");//如果路径不存在，创建⼀个File realPath = new File(path);if (!realPath.exists()) {realPath.mkdir();}System.out.println("上传⽂件保存地址：" + realPath);InputStream is = file.getInputStream(); //⽂件输⼊流OutputStream os = new FileOutputStream(new File(realPath, uploadFileName)); //⽂件输出流//读取写出int len = 0;byte[] buffer = new byte[1024];while ((len = is.read(buffer)) != -1) {os.write(buffer, 0, len);os.flush();}os.close();is.close();return "redirect:/index.jsp";}}2. Tansto⽅法package com.wang.controller;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RequestParam;import org.springframework.web.bind.annotation.RestController;import monsMultipartFile;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import java.io.*;import .URLEncoder;@RestControllerpublic class FileController {/** 采⽤file.Transto 来保存上传的⽂件*/@RequestMapping("/upload2")public String fileUpload2(@RequestParam("file") CommonsMultipartFile file, HttpServletRequest request) throws IOException { //上传路径保存设置String path = request.getServletContext().getRealPath("/upload");File realPath = new File(path);if (!realPath.exists()) {realPath.mkdir();}//上传⽂件地址System.out.println("上传⽂件保存地址：" + realPath);//通过CommonsMultipartFile的⽅法直接写⽂件（注意这个时候）file.transferTo(new File(realPath + "/" + file.getOriginalFilename()));return "redirect:/index.jsp";}}2. ⽂件下载1. 前端设计利⽤a标签实现跳转<%--Created by IntelliJ IDEA.User: WangDate: 2020/9/11Time: 16:48To change this template use File | Settings | File Templates.--%><%@ page contentType="text/html;charset=UTF-8" language="java" %><html><head><title>$Title$</title></head><body><a href="${pageContext.request.contextPath}/download">点击下载</a></body></html>2. controller设置⽂件下载步骤：1、设置 response 响应头2、读取⽂件 -- InputStream3、写出⽂件 -- OutputStream4、执⾏操作5、关闭流（先开后关）package com.wang.controller;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RequestParam;import org.springframework.web.bind.annotation.RestController;import monsMultipartFile;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import java.io.*;import .URLEncoder;@RestControllerpublic class FileController {@RequestMapping(value="/download")public String downloads(HttpServletResponse response , HttpServletRequest request) throws Exception {//要下载的图⽚地址String path = request.getServletContext().getRealPath("/upload");String fileName = "基础语法.jpg";//1、设置response 响应头response.reset(); //设置页⾯不缓存,清空bufferresponse.setCharacterEncoding("UTF-8"); //字符编码response.setContentType("multipart/form-data"); //⼆进制传输数据//设置响应头response.setHeader("Content-Disposition","attachment;fileName=" + URLEncoder.encode(fileName, "UTF-8")); File file = new File(path, fileName);//2、读取⽂件--输⼊流InputStream input = new FileInputStream(file);//3、写出⽂件--输出流OutputStream out = response.getOutputStream();byte[] buff = new byte[1024];int index = 0;//4、执⾏写出操作while ((index = input.read(buff)) != -1) {out.write(buff, 0, index);out.flush();}out.close();input.close();return null;}}。
JQuery与springmvc实现多个文件上传操作
本文由我司收集整编，推荐下载，如有疑问，请与我司联系JQuery 与springmvc 实现多个文件上传操作1. 导入JQuery 相关JS 文件script src=“ @full_path path=“js/jquery.js”/“type=“text/javascript” /scriptscript src=“ @full_path path=“js/ajaxfileupload.js”/“type=“text/javascript” /script这边ajaxfileupload.js 有点特殊，请使用如下改造后的原文件内容：jQuery.extend({ var frameId = ‘jUploadFrame’ + id; var iframeHtml = ‘ iframe id=“‘ + frameId + ‘“name=“‘+ frameId + ‘“‘;if(window.ActiveXObject) if(typeof uri==‘boolean’){iframeHtml += ‘src=“‘+ ‘javascript:false’+ ‘“‘;else if(typeof uri==‘string’){iframeHtml += ‘src=“‘+ uri + ‘“‘;iframeHtml += ‘/ jQuery(iframeHtml).appendTo(document.body); return jQuery(‘#’+ frameId).get(0); createUploadForm: function(id, fileElementId, data) //create form var formId = ‘jUploadForm’+ id; var fileId = ‘jUploadFile’+ id; var form = jQuery(‘form action=““method=“POST”name=“‘+ formId + ‘“id=“‘+ formId + ‘“enctype=“multipart/form-data” /form if (data) { for ( var i in data) { jQuery( ‘ input type=“hidden”name=“‘ + i + ‘“value=“‘+ data[i] + ‘“ / ‘).appendTo(form);for (var i= 0; i fileElementId.length; i ++) { var oldElement = jQuery(‘#’+ fileElementId[i]); var newElement = jQuery(oldElement).clone(); jQuery(oldElement).attr(‘id’, fileElementId[i]); jQuery(oldElement).attr(‘name’,fileElementId[i]); jQuery(oldElement).before(newElement); jQuery(oldElement).appendTo(form); //set attributes jQuery(form).css(‘position’,‘absolute’);jQuery(form).css(‘top’,‘-1200px’); jQuery(form).css(‘left’,‘-1200px’);jQuery(form).appendTo(‘body’);return form; ajaxFileUpload: function(s) { // TODO introduce global settings, allowing the client to modify them for all requests, not only timeout s = jQuery.extend({}, jQuery.ajaxSettings, s); var id = new Date().getTime() var form = jQuery.createUploadForm(id, s.fileElementId, (typeof(s.data)==‘undefined’?false:s.data));。
详解SpringMVC使用MultipartFile实现文件的上传
详解SpringMVC使⽤MultipartFile实现⽂件的上传如果需要实现跨服务器上传⽂件，就是将我们本地的⽂件上传到资源服务器上，⽐较好的办法就是通过ftp上传。
这⾥是结合SpringMVC+ftp的形式上传的。
我们需要先懂得如何配置springMVC，然后在配置ftp，最后再结合MultipartFile上传⽂件。
springMVC上传需要⼏个关键jar包，spring以及关联包可以⾃⼰配置，这⾥主要说明关键的jar包1：spring-web-3.2.9.RELEASE.jar (spring的关键jar包，版本可以⾃⼰选择)2：commons-io-2.2.jar (项⽬中⽤来处理IO的⼀些⼯具类包)配置⽂件SpringMVC是⽤MultipartFile来进⾏⽂件上传的，因此我们先要配置MultipartResolver，⽤于处理表单中的file<!-- 上传⽂件解释器 --><bean id="multipartResolver" class="monsMultipartResolver"><property name="defaultEncoding" value="utf-8" /><property name="maxUploadSize" value="10485760" /><property name="maxInMemorySize" value="4096" /><property name="resolveLazily" value="true" /></bean>其中属性详解：defaultEncoding配置请求的编码格式，默认为iso-8859-1maxUploadSize配置⽂件的最⼤单位，单位为字节maxInMemorySize配置上传⽂件的缓存，单位为字节resolveLazily属性启⽤是为了推迟⽂件解析，以便在UploadAction 中捕获⽂件⼤⼩异常页⾯配置在页⾯的form中加上enctype="multipart/form-data"<form id="" name="" method="post" action="" enctype="multipart/form-data">表单标签中设置enctype="multipart/form-data"来确保匿名上载⽂件的正确编码。
SpringMVC基于注解方式实现上传下载
SpringMVC基于注解⽅式实现上传下载⽬录⼀、⽂件下载1-1、servlet原⽣⽅式下载1-2、使⽤ResponseEntity实现下载⼆、⽂件上传2-1、添加commons-fileupload依赖2-2、配置spring.xml注⼊CommonsMultipartResolver⽂件上传解析器2-3、⽂件上传⼀、⽂件下载1-1、servlet原⽣⽅式下载/*** 基于servlet api的⽂件下载*/@RequestMapping("/download")public String download(HttpServletRequest request,HttpServletResponse response) throws IOException {// 获得当前项⽬路径下的下载⽂件（真实开发中⽂件名肯定是从数据中读取的）String realPath =request.getServletContext().getRealPath("/file/20181129204254948.png");// 根据⽂件路径封装成了File对象File tmpFile=new File(realPath);// 可以直接根据File对象获得⽂件名String fileName = tmpFile.getName();// 设置响应头 content-disposition：就是设置⽂件下载的打开⽅式，默认会在⽹页上打开，// 设置attachment;filename= 就是为了以下载⽅式来打开⽂件// "UTF-8"设置如果⽂件名有中⽂就不会乱码response.setHeader("content-disposition", "attachment;filename="+ URLEncoder.encode(fileName, "UTF-8"));// 根据⽂件路径封装成⽂件输⼊流InputStream in = new FileInputStream(realPath);int len = 0;// 声明了⼀个1KB的字节的缓冲区byte[] buffer = new byte[1024];// 获取输出流OutputStream out = response.getOutputStream();// 循环读取⽂件，每次读1KB，避免内存溢出while ((len = in.read(buffer)) > 0) {// 往客户端写⼊out.write(buffer,0,len);//将缓冲区的数据输出到客户端浏览器}in.close();return null;}以上代码中需要注意的地⽅我们设置了响应头response.setHeader("content-disposition", "attachment;filename="+ URLEncoder.encode(fileName, "UTF-8"));其中content-disposition可以让前端以⽂件的形式下载，否则就会直接在浏览器打开了1-2、使⽤ResponseEntity实现下载可以同时定制响应数据的内容、响应头以及响应状态码1-2-1、使⽤ResponseEntity实现响应内容的定制。
【SpringFramework】SpringMVC实现文件上传
【SpringFramework】SpringMVC实现⽂件上传SpringMVC 实现⽂件上传⽂件上传回顾实现步骤：客户端：发送 post 请求，告诉服务器要上传什么⽂件服务器：要有⼀个 form 标签，method=post 请求，form 标签的 encType 属性值必须为 multipart/form-data 值在 form 标签中使⽤ input type=file 添加上传的⽂件接收并处理上传的⽂件⽂件上传时 HTTP 协议说明：Content-type 表⽰提交的数据类型multipart/form-data 表⽰提交的数据，以多段（每⼀个表单项代表⼀个数据段）的形式进⾏拼接，然后以⼆进制流的形式发送给服务器boundary 表⽰每段数据的分隔符，它的值是有浏览器随机⽣成的，它是每段数据的分割符实现上传下载功能常⽤两个包：commons-fileupload-1.3.1.jarcommons-io-2.4.jarFileUploadController.java@Controller@RequestMapping("/file")public class FileUploadController {/*** ⽂件上传回顾* @return*/@RequestMapping(path = {"/upload1"})public String upload1(HttpServletRequest request) throws Exception {System.out.println("called upload1...");String path = request.getSession().getServletContext().getRealPath("/uploads"); // 获取到要上传的⽂件⽬录System.out.println(path);File file = new File(path);if (!file.exists()) {file.mkdirs();}DiskFileItemFactory factory = new DiskFileItemFactory(); // 创建磁盘⽂件项⼯⼚ServletFileUpload fileUpload = new ServletFileUpload(factory);List<FileItem> fileItems = fileUpload.parseRequest(request); // 解析request对象for (FileItem fileItem : fileItems) {if (fileItem.isFormField()) { // 判断⽂件项是普通字段，还是上传的⽂件System.out.println(fileItem.getName());} else {String itemName = fileItem.getName(); // 获取到上传⽂件的名称itemName = UUID.randomUUID().toString() + "-" + itemName; // 把⽂件名唯⼀化fileItem.write(new File(file, itemName)); // 上传⽂件fileItem.delete();}}return "success";}}index.jsp<%@ page contentType="text/html;charset=UTF-8" language="java" %><html><head><title>⽂件上传</title></head><body><h3>⽂件上传回顾</h3><form action="file/upload1" method="post" enctype="multipart/form-data">名称：<input type="text" name="picName"/><br/>图⽚：<input type="file" name="picFile"/><br><input type="submit" value="上传⽂件"/></form></body></html>SpringMVC 传统⽅式的⽂件上传传统⽅式的⽂件上传，指的是我们上传的⽂件和访问的应⽤存在于同⼀台服务器上。
文件上传之MultipartFile使用
⽂件上传之MultipartFile使⽤转载⼀、单/多⽂件上传使⽤例⼦:⼯程路径如下-src|--main.java--controller--service|--config--ImageStorageProperties.java--WebAppConfig.java|--resource|--config--image-storage.properties1.controller层@CrossOrigin("*")@RequestMapping(value = "/putImages",method = RequestMethod.POST, headers = "Accept=application/json")public String putImages(@RequestBody MultipartFile[] files, HttpServletRequest request) {return putImgService.putImages(files,request);}2.service层/*** 图⽚单/多张上传* @param files ⽂件* @return*/public String putImages(MultipartFile[] files, HttpServletRequest request) {String imgName = "";if (files == null || files.length == 0) {return "图⽚为空";}//遍历并保存⽂件for (MultipartFile file : files) {// 图⽚传到服务器imgName=imgUpload(file);if ("".equals(imgName)) {return "图⽚上传失败";}}return "图⽚上传成功";}/*** 图⽚传到服务器* @param file* @return图⽚路径*/public String imgUpload(MultipartFile file) {String fileName = file.getOriginalFilename();String suffixName = fileName.substring(stIndexOf("."));fileName = UUID.randomUUID() + suffixName;// 图⽚存储地址，例如"E:/imagesServer/"String parent = imageStorageProperties.getStoreUrl();String imgName = "";try {File targetFile = new File(parent, fileName);// 创建⽂件夹if (!targetFile.getParentFile().exists()) {targetFile.getParentFile().mkdirs();}// 将上传⽂件存储到服务器中file.transferTo(targetFile);// 背景图⽚地址imgName = targetFile.getName();// 图⽚显⽰地址，例如"http://localhost:8080/imgFiles/" + imgNameimgName = imageStorageProperties.getHttpUrl() + imgName;System.out.println(imgName);} catch (IOException e) {e.printStackTrace();}return imgName;}3.⽂件存储路径配置1）image-storage.properties配置⽂件如下image.httpUrl=http://localhost:8080/imgFiles/image.storeUrl=E:/imagesServer/2）ImageStorageProperties.java配置类如下@ConfigurationProperties(prefix = "image", ignoreUnknownFields = false)@PropertySource(value = {"classpath:config/image-storage.properties"},encoding="utf-8")public class ImageStorageProperties {private String httpUrl;private String storeUrl;public String getHttpUrl() {return httpUrl;}public void setHttpUrl(String httpUrl) {this.httpUrl = httpUrl;}public String getStoreUrl() {return storeUrl;}public void setStoreUrl(String storeUrl) {this.storeUrl = storeUrl;}}4.拦截器配置WebAppConfig.java配置如下import org.springframework.beans.factory.annotation.Autowired;import org.springframework.context.annotation.Configuration;import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;@Configurationpublic class WebAppConfig extends WebMvcConfigurerAdapter {@Autowiredprivate ImageStorageProperties imageStorageProperties;@Overridepublic void addResourceHandlers(ResourceHandlerRegistry registry) {registry.addResourceHandler("/imgFiles/**").addResourceLocations("file:"+imageStorageProperties.getStoreUrl());super.addResourceHandlers(registry);}}。
SpringMVC中MultipartFile上传获取图片的宽度和高度详解
SpringMVC中MultipartFile上传获取图⽚的宽度和⾼度详解SpringMVC⼀般使⽤MultipartFile来做⽂件的上传，通过MultipartFile的getContentType()⽅法判定⽂件的类型（MIME）“.doc”：”application/msword”“.jpg”：”image/jpeg”“.jpeg”：”image/jpeg”“.png”：”image/png”….有时项⽬当中，上传图⽚了，需要判定图⽚的约束规格，⽐如宽度和⾼度是不是符合要求，不符合要求的展⽰出来也会变形，或者模糊不清晰。
我们可以通过javax.imageio.ImageIO和java.awt.image.BufferedImage来获取到图⽚的宽度和⾼度。
代码如下：/*** 上传图⽚* @param file* @return* @throws IOException* @throws Exception*/@RequestMapping(value = "/uploadImg", method = RequestMethod.POST, produces = "text/html;charset=UTF-8")public String upload(@RequestParam(value = "file", required = true) MultipartFile file) {System.out.println(file.getContentType());System.out.println(file.getName());System.out.println(file.getOriginalFilename());try {BufferedImage image = ImageIO.read(file.getInputStream());if (image != null) {//如果image=null 表⽰上传的不是图⽚格式System.out.println(image.getWidth());//获取图⽚宽度，单位pxSystem.out.println(image.getHeight());//获取图⽚⾼度，单位px}} catch (IOException e) {e.printStackTrace();}return "hello";}BufferedImage image获取的对象如果是空的话，表⽰上传⽂件⽆法转换成图⽚对象，这也说明上传的⽂件不是图⽚可以⽤作上传⽂件被篡改成图⽚格式的判定，如：上传⽂件是123.doc，被前端篡改成123.png此时通过MultipartFile的getContentType()的⽅法获取的MIME居然是：”image/png”。
SpringBoot中的multipartResolver上传文件配置
SpringBoot中的multipartResolver上传⽂件配置⽬录multipartResolver上传⽂件配置1、gradle配置2、注册BeanSpringBootMultipartResolver的坑解决⽅案multipartResolver上传⽂件配置1、gradle配置compile ('commons-io:commons-io:1.4')compile('commons-fileupload:commons-fileupload:1.2.1')2、注册Bean@Bean(name = "multipartResolver")public MultipartResolver multipartResolver(){CommonsMultipartResolver resolver = new CommonsMultipartResolver();resolver.setDefaultEncoding("UTF-8");//resolveLazily属性启⽤是为了推迟⽂件解析，以在在UploadAction中捕获⽂件⼤⼩异常resolver.setResolveLazily(true);resolver.setMaxInMemorySize(40960);//上传⽂件⼤⼩ 50M 50*1024*1024resolver.setMaxUploadSize(50*1024*1024);return resolver;}SpringBoot MultipartResolver的坑在使⽤springBoot上传⽂件的时候，我们会⽤到MultipartResolver。
我看通过源码可以看到@Configuration@ConditionalOnClass({ Servlet.class, StandardServletMultipartResolver.class,MultipartConfigElement.class })@ConditionalOnProperty(prefix = "spring.http.multipart", name = "enabled", matchIfMissing = true)@EnableConfigurationProperties(MultipartProperties.class)public class MultipartAutoConfiguration {private final MultipartProperties multipartProperties;public MultipartAutoConfiguration(MultipartProperties multipartProperties) {this.multipartProperties = multipartProperties;}@Bean@ConditionalOnMissingBean({ MultipartConfigElement.class,CommonsMultipartResolver.class })public MultipartConfigElement multipartConfigElement() {return this.multipartProperties.createMultipartConfig();}@Bean(name = DispatcherServlet.MULTIPART_RESOLVER_BEAN_NAME)@ConditionalOnMissingBean(MultipartResolver.class)public StandardServletMultipartResolver multipartResolver() {StandardServletMultipartResolver multipartResolver = new StandardServletMultipartResolver();multipartResolver.setResolveLazily(this.multipartProperties.isResolveLazily());return multipartResolver;}可以看出MultipartAutoConfiguration配置类，默认加载的是StandardServletMultipartResolver。
MultipartFile多文件上传的应用
MultipartFile多⽂件上传的应⽤公司的项⽬很多地⽅要⽤到⽂件上传，以前的上传主要是⽤apache的fileupload ,使⽤的感受并不太好。
今天试了试spring的MultipartFile，感觉还不错，封装的⽐较简洁。
当然，中间也排除了不少坑。
1. 配置CommonsMultipartResolver1<!-- 配置MultipartResolver ⽤于⽂件上传使⽤spring的CommosMultipartResolver -->2<bean id="multipartResolver" class="monsMultipartResolver">3<property name="defaultEncoding" value="UTF-8"/>4<property name="maxUploadSize" value="209715200"/>5<property name="maxInMemorySize" value="4096"/>6<property name="uploadTempDir" value="fileUpload/temp"/>7</bean>defaultEncoding="UTF-8" 是请求的编码格式，默认为iso-8859-1maxUploadSize="209715200" 是上传⽂件的总的⼤⼩，单位为字节，我设置的是200M,uploadTempDir="fileUpload/temp" 为上传⽂件的临时路径2. 添加apache的 fileupload1<dependency>2<groupId>commons-fileupload</groupId>3<artifactId>commons-fileupload</artifactId>4<version>1.2.2</version>5</dependency>应该是multipartfile⽅式上传底层也会⽤到commons-fileupload3.前端⽤了jquery file upload1<span class="btn btn-success fileinput-button">2<i class="glyphicon glyphicon-plus"></i>3<span>选择⽂件...</span>4<!-- The file input field used as target for the file upload widget -->5<input id="fileupload" type="file" name="file[]" multiple>6</span>7 #jquery file upload 没有采⽤form表单上传，是ajax⽅式向后台发送的请求，#如果是以表单形式提交上传请求，不要忘了加上enctype="multipart/form-data"8 ...910 $('#fileupload').fileupload({11 url: "<%=request.getContextPath()%>/aaa/upload.do",12 sequentialUploads: true,13 singleFileUploads: false,14 add: function (e, data) {15 data.context = $('<button/>').text('Upload')16 .appendTo(document.body)17 .click(function () {18 data.context = $('<p/>').text('Uploading...').replaceAll($(this));19 data.submit();20 });21 },22 done: function (e, data) {23 $.each(data.files, function (index, file) {24 $('<p/>').text().appendTo(document.body);25 });26 }27 });jquery file upload 看起来还不错，就是中⽂的资料还是有点少，官⽹看的头⼤。
multipartfile使用场景
【主题】MultipartFile的使用场景1. MultipartFile概述MultipartFile是Spring框架中用于处理文件上传的接口，它可以代表一个多部分文件上传请求中的一个文件。
在Spring MVC中，通常通过MultipartFile接口来接收客户端上传的文件数据。
MultipartFile 接口提供了一系列方法用于获取文件的各种属性和内容，使得在后端处理文件上传变得十分方便。
2. Web应用中的图片上传在Web应用中，图片上传是一种常见的场景。
用户需要上传头像、相片、证件照等图片文件，而后端需要接收并保存这些文件。
使用MultipartFile接口可以轻松地实现图片文件的接收和处理，通过获取文件的原始文件名、内容类型、大小等属性，实现对图片文件的有效管理和存储。
3. 文件上传与表单数据一起提交有时候，前端页面会采用form表单的方式来提交信息，其中不仅包括文本数据，还包括了文件数据。
这时候MultipartFile就可以派上用场，它能够很好地和表单数据一起提交，并在后端进行统一处理。
通过MultipartFile接口，我们可以方便地获取表单中的文件数据，并结合其他表单字段一起进行处理，实现信息的完整提交和保存。
4. 多文件上传除了单个文件上传外，有时候用户需要一次性上传多个文件，比如批量上传照片、文档等。
使用MultipartFile接口可以很好地支持多文件上传的场景。
通过对MultipartFile数组的处理，后端可以轻松地接收多个文件，并分别对它们进行处理，提高了上传文件的效率和用户体验。
5. 文件下载与导出除了接收文件上传外，MultipartFile接口在文件下载和导出方面也有一定的应用场景。
通过将MultipartFile转换为文件流，后端可以实现文件的下载和导出操作，满足用户对文件的查看和使用需求。
6. 结语MultipartFile作为Spring框架中处理文件上传的重要接口，在Web 应用中有着广泛的应用场景。
使用MultipartFile做文件上传的功能
使用MultipartFile做文件上传的功能文件上传是Web开发中常见的功能，用于将用户选择的文件发送到服务器端存储或处理。
在Spring框架中，可以使用MultipartFile接口来处理文件上传的相关操作。
MultipartFile接口是Spring框架提供的一个用于处理文件上传的接口，它继承自org.springframework.core.io.InputStreamSource接口，提供了一些方法用于获取文件名称、获取文件大小、获取文件输入流等。
```java//处理文件上传的逻辑//...```在处理文件上传的方法中，可以通过MultipartFile接口提供的方法来获取文件的信息，例如文件名称、文件大小等。
例如：```javaString fileName = file.getOriginalFilename(;long fileSize = file.getSize(;//输出文件信息System.out.println("文件名称：" + fileName);System.out.println("文件大小：" + fileSize);//处理文件上传的逻辑//...```在上述代码中，调用了MultipartFile的getOriginalFilename(方法来获取文件的原始名称，调用getSize(方法来获取文件的大小。
处理文件上传的逻辑可以根据具体需求来确定，一般包括以下几步：1.检查文件类型和大小：可以根据需求来验证上传的文件类型和大小是否符合要求，例如只允许上传指定类型的文件，或者限制文件的大小。
2. 存储文件：可以将接收到的文件存储到指定的位置，如本地文件系统或数据库中。
可以使用java.io包提供的类来进行文件存储操作。
3.返回反馈信息：可以根据文件上传的结果返回相应的反馈信息给用户，例如上传成功或失败的提示。
在文件上传过程中还有一些其他的注意事项和功能，例如文件上传的进度显示、多文件同时上传等。
multipartfile 参数
multipartfile 参数multipartfile参数是Java Spring框架中接受上传文件时使用的一种数据类型，该数据类型代表一个二进制文件的容器，可以传输不同格式的多个文件。
在Spring MVC中，上传文件时需要使用multipartfile类型的参数，在接受请求时，该参数会自动解析上传的二进制数据并存储在内存中。
可以使用MultipartFile对象访问文件内容和文件元数据（如文件名、文件大小、文件类型等）。
常见的方法包括：- getOriginalFilename()：获取上传文件时的原始名称。
- getSize()：获取上传文件的大小。
- getContentType()：获取上传文件的MIME类型。
- getBytes()：以字节数组的形式获取文件内容。
- transferTo(File dest)：将上传的文件保存到指定目录。
在控制器方法中使用MultipartFile参数时，需要在请求处理方法的参数列表中使用该参数类型，并在该参数前加上@RequestParam注解指定参数名称，如下所示：```java@PostMapping("/upload")public String handleFileUpload(@RequestParam("file") MultipartFile file) {// 处理上传文件}```其中，@RequestParam("file")表示请求中包含名为file的参数，并将其绑定到方法中的MultipartFile对象上。
如果上传的文件名不为file，需要将@RequestParam中的参数名修改为上传文件的实际名称。
除了MultipartFile参数外，还可以使用HttpServletRequest或MultipartHttpServletRequest对象获取上传文件的信息。
springMVC的多文件的异步上传实现
springMVC的多⽂件的异步上传实现 springMVC的MultipartFile与传统的ajax⽂件上传兼容性不好，采⽤如下的ajax⽅法，后台⽆法获取⽂件。
$.ajax({ url: '/upload', type: 'POST', cache: false, data: new FormData($('#uploadForm')[0]), processData: false, contentType: false}).done(function(res) { }).fail(function(res) {}); 服务器端代码需要使⽤从查询参数名为file获取⽂件输⼊流对象，因为<input>中声明的是name="file"，但是上述⽅式，只能传递⼀般的参数，上传⽂件的⽂件流是⽆法被序列化并传递的。
------------------------------------------------------------------------------------分割线------------------------------------------------------------------------------------采⽤以下⽅式完美解决：1.引⼊需要的js⽂件<script type="text/javascript" src="../lycaen/js/jquery/jquery.min.js"></script><script type="text/javascript" src="../lycaen/js/jquery/jquery-ui.min.js"></script><script type="text/javascript" src="../lycaen/js/jquery/jquery-form.js"></script>2.web.xml引⼊MultiFileUpload<?xml version="1.0" encoding="UTF-8"?><web-app version="2.4" xmlns="/xml/ns/j2ee"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/xml/ns/j2ee/xml/ns/j2ee/web-app_2_4.xsd"> <!-- ⼯程采⽤hi平台，class⾃⾏修改 --><servlet><servlet-name>MultiFileUpload</servlet-name><servlet-class>org.hi.framework.lycaen.servlet.MultiFileUpload</servlet-class></servlet><servlet-mapping><servlet-name>MultiFileUpload</servlet-name><url-pattern>/MultiFileUpload</url-pattern></servlet-mapping>3.spring容器定义multipartResolver<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "/dtd/spring-beans.dtd"><beans><!-- ⼯程采⽤hi平台，class⾃⾏修改 --><bean id="multipartResolver" class="org.hi.framework.HiMultipartResolver"><!-- url中带有该属性值的 http 请求就不会被 multipartResolver 先解析 --><property name="excludeUrls" value="lycaenMultipleFileUpload"/><property name="maxUploadSize" value="100000000"/><property name="defaultEncoding" value="UTF-8"/></bean></beans>4.前台demo<!DOCTYPE html><head><meta charset="UTF-8"><title>Title</title></head><body><style type="text/css">div.mainContener{padding-top: 10px;padding-right: 10px;padding-bottom: 10px;padding-left: 10px;}#submit_click { text-align:center;margin-top:32px; height:40px;}#submit_click a{text-decoration:none;background:#0a6dbe;color:#f2f2f2;padding: 10px 30px 10px 30px;font-size:16px;font-family:微软雅⿊,宋体,Arial,Helvetica,Verdana,sans-serif; font-weight:bold;border-radius:3px;-webkit-transition:all linear 0.30s;-moz-transition:all linear 0.30s;transition:all linear 0.30s;}#submit_click a:hover { background:#385f9e; }.upload_click { text-align:center;margin-top:32px; height:40px;} .uoload_click a{text-decoration:none;background:#2f435e;color:#f2f2f2;padding: 10px 30px 10px 30px;font-size:16px;font-family:微软雅⿊,宋体,Arial,Helvetica,Verdana,sans-serif; font-weight:bold;border-radius:3px;-webkit-transition:all linear 0.30s;-moz-transition:all linear 0.30s;transition:all linear 0.30s;}table.gridtable {font-family: Microsoft YaHei;font-size:14px;color:#333333;border-width:1px;border-color:#666666;border-collapse: collapse;padding-top: 10px;padding-right: 10px;padding-bottom: 10px;padding-left: 10px;}table.gridtable .title {font-weight:bold;background-color:#f2f5f7;text-align:center;}table.gridtable th {border-width: 1px;padding: 8px;border-style: solid;border-color: #ced9e0;background-color: #e0ecff;}table.gridtable td {border-width: 1px;padding: 8px;border-style: solid;border-color: #ced9e0;background-color: #ffffff;}input[type=button]{height:30px;width:236px;background-color:#d7ebf9;border:1px solid #99D3F5;border-radius:3px;font-size:14px;color:#0078de;}td.leftHead{text-align: center;}</style><div class="mainContener"><table class="gridtable" align = "center" width="98%"><tr class="title"><th width="15%">考核要点（分值）</th><th width="60%">考核内容</th><th width="25%">附件材料要求</th><th width="5%">附件上传</th><th width="10%">⾃评评分</th><th width="10%">上级评分</th></tr><tr><td class="leftHead" rowspan = 7>1.<br>部<br>署<br>⼯<br>作<br>（<br>8<br>分<br>）</td><td>（1）政府⼯作报告对⾷品安全⼯作有明确要求，得0.5分，否则不得分</td><td>2017年省级政府⼯作报告</td><td><form id= "uploadForm111" name="uploadForm111" enctype="multipart/form-data"><input name="messageContent" type="hidden"/><p><input type="file" name="file"/></p><p><div style="text-align:center"><input type="button" value="上传" onclick="doUpload($(this))"/></div></p></form></td><td><input type="number" width="98%"/></td><td><input type="number" width="98%"/></td></tr><tr><td>（2）组织制定并向社会公布⾷品安全重点⼯作安排。
SpringMVC参数映射与文件上传
SpringMVC参数映射与⽂件上传handler参数映射:接下来就是Spring的各个处理细节了,⽆论框架如何疯转其实我们处理请求的流程是不变的,设计到的操作也是固定的,举个例⼦,当我们要实现⼀个登陆功能时:创建⼀个⽤于处理登录请求的Servlet实现doget等其他http⽅法(⼀些情况可能根据业务需要限制请求⽅法)从request对象中取出数据处理编码验证参数是否符合要求对参数数据类型进⾏转换(需要时)开始业务逻辑处理(登录)可能需要操作session来完成组织响应给数据,可能是html可能是json,异常处理Header与cookie的处理整个SpringMVC其实就是帮我们对上⾯的操作进⾏封装,当然了SpringMVC也提供了更多的功能,如国际化..Handler⽅法特殊参数在handler⽅法中我们可以添加⼀下参数,⽤于获取⼀些特殊的对象:HttpServletRequest,HttpServletResponseHttpSessionModelModelMapmodel 是框架帮我们创建好的的Model对象,若使⽤该参数作为返回的model,则需要修改⽅法返回值为String⽤于指定视图名称;案例:@RequestMapping("/courseList2.action")public String courseList(Model model) {model.addAttribute("courses", courseService.selectCourseList());return "courses.jsp";}@RequestMapping("/courseList3.action")public String courseList(ModelMap model, HttpSession session,HttpServletRequest request,HttpServletResponse response) {System.out.println(request);System.out.println(response);System.out.println(session.getId());model.addAttribute("courses", courseService.selectCourseList());return "courses.jsp";}请求参数映射:在使⽤Servlet开发的过程中我们会频繁的调⽤request.getAttribute来获取请求参数,参数较少时还没什么,⼀旦参数较多的时候就会产⽣⼤量的冗余代码,SpringMVC提供了多种以简化获取参数的过程的⽅法映射到handler⽅法的参数在handler⽅法中添加与前台参数名称和类型匹配的参数,框架会⾃动解析参数传⼊handler⽅法中;案例:假设我们要修改课程信息的功能,⾸先要获取原始信息@RequestMapping("/edit.action")public String edit(Model model,Integer id) {Course course = courseService.selectCourseByID(id);model.addAttribute("course",course);return "edit.jsp";}⽀持的参数类型:整形:Integer、int字符串:String单精度:Float、float双精度:Double、double布尔型:Boolean、boolean@RequestParam当前后台参数名称不匹配时可以@RequestParam注解进⾏⾃定义映射;注解参数:value,name 两者都代表前台参数名称requerid 该参数是否必须defaultValue 参数默认值案例:@RequestMapping("/edit.action")public String edit(Model model,@RequestParam("id") Integer iid) {Course course = courseService.selectCourseByID(iid);model.addAttribute("course",course);注意:参数类型可以是基础类型也可以是包装类型,建议使⽤包装类型,这样可以保证为获取到参数时不会因为null⽆法转换为基础类型⽽导致的异常;edit.jsp:<%@ taglib prefix="c" uri="/jsp/jstl/core" %><%@ taglib prefix="fmt" uri="/jsp/jstl/fmt" %><%@ page contentType="text/html;charset=UTF-8" language="java" %><html><head></head><form action="updateCourse.action" method="post"><input name="id" value="${course.id}" hidden="hidden"/><input name="name" value="${}"/><input name="teachName" value="${course.teachName}"/><%-- <input name="startTime" type="date" value='<fmt:formatDate value="${course.startTime}" pattern="yyyy-MM-dd"/>'/>--%><input name="score" type="number" value="${course.score}"/><input name="hours" type="number" value="${course.hours}"/><input type="submit"></form><body></body></html>映射到实体类当参数个数⾮常多时上⾯的⽅法就显得⿇烦了,SpringMVC⽀持将参数映射到⼀个实体类;在handler⽅法中添加任意类型实体类作为参数; 同样的只有参数名称和实体属性⼀致时才能映射成功;我们继续完善修改功能,现在要获取修改后的内容了:@RequestMapping("/updateCourse.action")public String update(Course course) {courseService.updateCourse(course);return "/courseList.action";}乱码过滤器上⾯的例⼦中出现了中⽂乱码问题,请求⽅法为post, 只需要在request中设置编码⽅式即可,但是此时参数已经被框架解析了,我们在handler中通过request设置以及不⽣效了,所以我们需要在请求到达SpringMVC之前就进⾏处理,这就⽤到了以前学过的过滤器了;好消息是SpringMVC以及提供了过滤器,我们只需要配置到web.xml中即可<!-- 编码过滤器--><filter><filter-name>encodingFilter</filter-name><filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class><init-param><param-name>encoding</param-name><param-value>utf-8</param-value></init-param><!-- 是否对响应设置编码 --><init-param><param-name>forceResponseEncoding</param-name><param-value>true</param-value></init-param></filter><filter-mapping><filter-name>encodingFilter</filter-name><url-pattern>/*</url-pattern></filter-mapping><!-- 编码过滤器 END-->需要注意的是,该过滤器只对post⽣效,如果是get乱码则还是需要修改tomcat的server.xml或是通过代码从ISO-8859-重新编码为UTF-8String username = request.getParameter("username");username = new String(username.getBytes("iso8859-1"), "utf-8"); //重新编码参数类型转换我们将edit.jsp中的开课标签取消注释,然后测试会发现系统给出了400异常,查看控制台可以看到以下信息:意思是框架⽆法将String类型的请求参数转换为需要的Date类型,这就需要,这是因为⽇期格式多种多样,每个地区不同,所以这需要我们⾃⼰来实现转换;编写转换器实现convert接⼝即可作为转换器,该接⼝的两个两个泛型表⽰输⼊源类型和输出⽬标类型;public class StringToDateConverter implements Converter<String, Date> {@Overridepublic Date convert(String s) {SimpleDateFormat sm = new SimpleDateFormat("yyyy-MM-dd");try {return sm.parse(s);} catch (ParseException e) {e.printStackTrace();}}mvc配置⽂件<bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean"><property name="converters"><set><bean class="com.kkb.converter.StringToDateConverter"/></set></property></bean><mvc:annotation-driven conversion-service="conversionService"/>使⽤注解注册转换器使⽤@DateTimeFormat可以实现上⾯xml相同的配置:public class Course {private Integer id;private String name;private String teachName;@DateTimeFormat(pattern = "yyyy-MM-dd")private Date startTime;}注意:注解作⽤在实体类对应的属性上,且配置⽂件必须添加<mvc:annotation-driven>包装类型映射当需要将参数映射到实体类的关联对象中时,也称为包装类型;例如:在课程对象中有⼀个⽤户对象,表⽰这是某个⽤户的课程;前台需要同时传递课程对象的属性,和⽤户对象的属性,后台就需要要⽤⼀个包装类型来接收,即⼀个包装了⽤户对象的课程对象; 再说的简单点,即课程对象中包含⼀个⽤户对象;在前台需要指出关联对象的属性名称,如:⽤户.name实体:public class Course {private Integer id;private String name;private String teachName;private Date startTime;private Integer score;private Integer hours;private User user;//新添加的User类属性set/get....handler:@RequestMapping("/updateCourse.action")public String update(Course course) {courseService.updateCourse(course);return "/courseList.action";}jsp:<form action="updateCourse.action" method="post"><input name="id" value="${course.id}" hidden="hidden"/><input name="name" value="${}"/><input name="teachName" value="${course.teachName}"/><input name="startTime" type="date" value='<fmt:formatDate value="${course.startTime}" pattern="yyyy-MM-dd"/>'/><input name="score" type="number" value="${course.score}"/><input name="hours" type="number" value="${course.hours}"/><input name="ername"/> <!-- 新添加的参数--><input type="submit"></form>数组参数映射⼀些情况下,某⼀参数可能会有多个值,例如要进⾏批量删除操作,要删除的id会有多个,那就需要将参数映射到⼀个数组中;HttPServletRequest原本就⽀持获取数组参数,SpringMVC仅是帮我们做了⼀个类型转换;1.修改页⾯添加多选框:<%@ page contentType="text/html;charset=UTF-8" language="java" %><%@ taglib prefix="c" uri="/jsp/jstl/core" %><%@ taglib prefix="fmt" uri="/jsp/jstl/fmt" %><html><head></head><body><form action="deleteCourses"><table border="1"><tr><th>选择</th><th>名称</th><th>讲师</th><th>开课⽇期</th><th>学分</th><th>课时</th><th>操作</th></tr><c:forEach items="${courses}" var="course"><tr><td><input type="checkbox" name="ids" value="${course.id}"></td><td>${}</td><td>${course.teachName}</td><td><fmt:formatDate value="${course.startTime}" pattern="yyyy-MM-dd"/></td><td>${course.score}</td><td>${course.hours}</td><td><a href="editCourse?id=${course.id}">修改</a></td></tr></c:forEach></table><input type="submit" value="批量删除"></form></body></html>2.handler⽅法:@RequestMapping("/deleteCourses")public String deleteCourses(Integer[] ids){courseService.deleteCourses(ids);return "/getCourses";}3.service⽅法:public void deleteCourses(Integer[] ids) {for (Integer id : ids){courseMapper.deleteByPrimaryKey(id);}}list映射当请求参数包含多个对象的属性数据,是需要使⽤list来接收,通常⽤在批量修改批量添加等;list映射要求参数名称为对象属性[下标].属性名称,同时handler中使要⽤包装类型来接收;以下是实现⼀个批量修改课程信息的功能;1.修改页⾯中的td,使得每⼀个td都可以编辑:<%@ page contentType="text/html;charset=UTF-8" language="java" %><%@ taglib prefix="c" uri="/jsp/jstl/core" %><%@ taglib prefix="fmt" uri="/jsp/jstl/fmt" %><html><head></head><body><form action="deleteCourses" id="fm"><table border="1"><tr><th>选择</th><th>名称</th><th>讲师</th><th>开课⽇期</th><th>学分</th><th>课时</th><th>操作</th></tr><c:forEach items="${courses}" var="course" varStatus="status"><tr><td><input type="checkbox" name="ids" value="${course.id}"></td><td><input value="${}" name="courses[${status.index}].name"/></td><td><input value="${course.teachName}" name="courses[${status.index}].teachName"/></td><td><input value='<fmt:formatDate value="${course.startTime}" pattern="yyyy-MM-dd"/>' name="courses[${status.index}].startTime"/></td> <td><input value="${course.score}" name="courses[${status.index}].score"/></td><td><input value="${course.hours}" name="courses[${status.index}].hours"/></td><input hidden="hidden" name="courses[${status.index}].id" value="${course.id}"><td><a href="editCourse?id=${course.id}">修改</a></td></tr></c:forEach></table><input type="submit" value="批量删除"><input type="button" onclick='function updates() {document.getElementById("fm").action = "updateCourses"document.getElementById("fm").submit()}updates()' value="批量修改"></form></body></html>2.包装类型:public class RequestPack {//⽤于接收参数列表的listprivate List<Course> courses;public List<Course> getCourses() {return courses;}public void setCourses(List<Course> courses) {this.courses = courses;}public RequestPack(List<Course> courses) {this.courses = courses;}}3.handler⽅法:@RequestMapping("/updateCourses")public String updateCourses(RequestPack data){courseService.updateCourses(data.getCourses());return "/getCourses";}4.service⽅法:public void updateCourses(List<Course> courses) {for (Course course:courses){courseMapper.updateByPrimaryKey(course);}}强调:list只能映射到包装类型中,⽆法直接映射到handler参数上错误案例:@RequestMapping("/updateCourses")public String updateCourses(RequestPack data, ArrayList<Course> courses){courseService.updateCourses(data.getCourses());return "/getCourses";}⽂件上传⽂件上传是web项⽬中⾮常常见的需求,SpringMVC使⽤了apache开源的两个库⽤于处理⽂件上传,所以在编写代码前我们需要先导⼊下⾯两个依赖包: <dependency> <groupId>commons-io</groupId> <artifactId>commons-io</artifactId> <version>2.6</version></dependency><dependency><groupId>commons-fileupload</groupId> <artifactId>commons-fileupload</artifactId> <version>1.4</version></dependency>假设需要实现⼀个上传图⽚的功能,需要现在数据库中添加⼀个字段⽤于存储图⽚的路径,同时不要忘记修改pojo以及mapper⽂件,使之与数据库字段对应1.页⾯增加input ⽤于提交⽂件,并修改表单的enctype为multipart/form-data<%@ taglib prefix="c" uri="/jsp/jstl/core" %><%@ taglib prefix="fmt" uri="/jsp/jstl/fmt" %><%@ page contentType="text/html;charset=UTF-8" language="java" %><html><head></head><form action="updateCourse" method="post" enctype="multipart/form-data"><input name="id" value="${course.id}" hidden="hidden"/>名称:<input name="name" value="${}"/><br/>讲师:<input name="teachName" value="${course.teachName}"/><br/><input name="startTime" type="date" value='<fmt:formatDate value="${course.startTime}" pattern="yyyy-MM-dd"/>'/><br/>学分:<input name="score" type="number" value="${course.score}"/><br/>课时:<input name="hours" type="number" value="${course.hours}"/><br/><c:if test="${course.pic != null}"><img src="${pageContext.servletContext.contextPath}${course.pic}" style="width: 100px;height: 100px"></c:if>图⽚:<input name="picFile" type="file"/><br/> <!-- 新增input--><br/><input type="submit"></form><body></body></html>2.在mvc配置⽂件中添加multipart解析器,(页⾯上传⽂件都是以,multipart编码⽅式)<bean id="multipartResolver" class="monsMultipartResolver"/>3.handler⽅法中添加MultipartFile类型的参数@RequestMapping("/updateCourse")public String updateCourse(Course course, MultipartFile picFile) throws IOException {/**** 1.获得⽂件,取出⽂件后缀* 2.⽣成唯⼀标识,* 3.写⼊⽂件到指定路径* 4.存储⽂件路径到数据库*/System.out.println(picFile.getName());String suffix = picFile.getOriginalFilename().substring(picFile.getOriginalFilename().lastIndexOf("."));String fileName = UUID.randomUUID() + suffix;String basepath = getClass().getClassLoader().getResource(".").getPath();System.out.println(basepath);picFile.transferTo(new File(basepath+"../../images/"+fileName));course.setPic("/images/"+fileName);courseService.update(course);return "/getCourses";}注意:实际开发中都是存储到⽂件服务器,不会放在项⽬⾥4.静态资源处若web.xml中DispatcherServlet的URLmapping 为/ 则还需要在SpringMVC中添加静态资源配置<mvc:resources mapping="/images/**" location="/images/"/><!--当请求地址为/images/开头时(⽆论后⾯有多少层⽬录),作为静态资源到/images/下查找⽂件-->若URLMapping为*.action 或类似其他的时则⽆需处理,因为Tomcat会直接查找webapp下的资源,不会交给DispatcherServlet请求限制⼀些情况下我们可能需要对请求进⾏限制,⽐如仅允许POST,GET等...RequestMapping注解中提供了多个参数⽤于添加请求的限制条件value 请求地址path 请求地址method 请求⽅法headers 请求头中必须包含指定字段params 必须包含某个请求参数consumes 接受的数据媒体类型 (与请求中的contentType匹配才处理)produce 返回的媒体类型 (与请求中的accept匹配才处理)案例:@RequestMapping(value = "/editCourse",method = RequestMethod.POST,headers = {"id"},params = {"name"},consumes = {"text/plain"})为了简化书写,MVC还提供了集合路径和⽅法限制的注解,包括常见的请求⽅法:PostMappingGetMappingDeleteMappingPutMapping例:@PostMapping("/editCourse")。
multipartfile[] 用法
![multipartfile[] 用法](https://img.taocdn.com/s3/m/f2c01a6c326c1eb91a37f111f18583d049640fb3.png)
multipartfile[] 用法
MultipartFile[]是SpringMVC中的一个参数类型，用于接收上传的多个文件。
其用法如下：
1.在Controller中定义方法，方法参数为MultipartFile[]类型。
2.前端页面中上传文件时，需要使用HTML表单中的<input type='file' name='file'/>标签，并设置name属性为“file”。
3.在Controller中，通过MultipartFile[]数组可以获取上传的多个文件信息，包括文件名、文件类型、文件大小等。
4.通过MultipartFile[]数组中的每个元素，可以使用getInputStream()方法获取文件的输入流，用于读取文件内容。
5.如果需要将上传的多个文件保存到服务器本地，可以使用Java IO流将文件写入到服务器指定位置。
6.最后，需要注意的是，在处理MultipartFile[]数组时，需要注意空指针异常的情况，即MultipartFile[]数组为空或其中某个元素为空的情况。
综上所述，MultipartFile[]是Spring MVC中用于接收上传的多个文件的参数类型，通过其可以获取上传的多个文件信息，并实现将文件保存到服务器本地的功能。
- 1 -。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
SpringMVC使用MultipartFile文件上传配置，多文件上传，.基本的SpringMVC的搭建在我的上一篇文章里已经写过了，这篇文章主要说明一下如何使用SpringMVC进行表单上的文件上传以及多个文件同时上传的步骤一、配置文件：SpringMVC 用的是的MultipartFile来进行文件上传所以我们首先要配置MultipartResolver:用于处理表单中的file1.<!-- 配置MultipartResolver 用于文件上传使用spring的CommosMultipartResolver -->2.<beans:bean id="multipartResolver"class="org.springframework.web.multipmonsMultipartResolver"3.p:defaultEncoding="UTF-8"4.p:maxUploadSize="5400000"5.p:uploadTempDir="fileUpload/temp"6.>7.</beans:bean>其中属性详解：defaultEncoding="UTF-8"是请求的编码格式，默认为iso-8859-1maxUploadSize="5400000"是上传文件的大小，单位为字节uploadTempDir="fileUpload/temp"为上传文件的临时路径二、创建一个简单的上传表单：1.<body>2.<h2>文件上传实例</h2>3.4.5.<form action="fileUpload.html"method="post"enctype="multipart/form-data">6.选择文件:<input type="file"name="file">7.<input type="submit"value="提交">8.</form>9.10.11.</body>注意要在form标签中加上enctype="multipart/form-data"表示该表单是要处理文件的,这是最基本的东西，很多人会忘记然而当上传出错后则去找程序的错误，却忘了这一点三、编写上传控制类1、创建一个控制类: FileUploadController和一个返回结果的页面list.jsp2、编写提交表单的action:1.//通过Spring的autowired注解获取spring默认配置的request2.@Autowired3.private HttpServletRequest request;4.5./***6. * 上传文件用@RequestParam注解来指定表单上的file为MultipartFile7. *8. * @param file9. * @return10. */11.@RequestMapping("fileUpload")12.public String fileUpload(@RequestParam("file") MultipartFile file) {13.// 判断文件是否为空14.if (!file.isEmpty()) {15.try {16.// 文件保存路径17. String filePath = request.getSession().getServletContext().getRealPath("/") + "upload/"18. + file.getOriginalFilename();19.// 转存文件20. file.transferTo(new File(filePath));21. } catch (Exception e) {22. e.printStackTrace();23. }24. }25.// 重定向26.return"redirect:/list.html";27. }28.29./***30. * 读取上传文件中得所有文件并返回31. *32. * @return33. */34.@RequestMapping("list")35.public ModelAndView list() {36. String filePath = request.getSession().getServletContext().getRealPath("/") + "upload/";37. ModelAndView mav = new ModelAndView("list");38. File uploadDest = new File(filePath);39. String[] fileNames = uploadDest.list();40.for (int i = 0; i < fileNames.length; i++) {41.//打印出文件名42. System.out.println(fileNames[i]);43. }44.return mav;45. }3、使用SpringMVC注解RequestParam来指定表单中的file参数；4、指定一个用于保存文件的web项目路径5、通过MultipartFile的transferTo(File dest)这个方法来转存文件到指定的路径。
到此基本的文件上传就结束了。
MultipartFile类常用的一些方法：String getContentType()//获取文件MIME类型InputStream getInputStream()//后去文件流String getName() //获取表单中文件组件的名字String getOriginalFilename() //获取上传文件的原名long getSize() //获取文件的字节大小，单位byteboolean isEmpty() //是否为空void transferTo(File dest) //保存到一个目标文件中。
四、多文件上传。
多文件上传其实很简单，和上传其他相同的参数如checkbox一样，表单中使用相同的名称，然后action中将MultipartFile参数类定义为数组就可以。
接下来实现：1、创建一个上传多文件的表单：[html]view plain copyprint?1.<body>2.<h2>上传多个文件实例</h2>3.4.5.<form action="filesUpload.html"method="post"6.enctype="multipart/form-data">7.<p>8.选择文件:<input type="file"name="files">9.<p>10.选择文件:<input type="file"name="files">11.<p>12.选择文件:<input type="file"name="files">13.<p>14.<input type="submit"value="提交">15.</form>16.</body>2、编写处理表单的action，将原来保存文件的方法单独写一个方法出来方便共用：1./***2. * 保存文件3. * @param file4. * @return5. */6.private boolean saveFile(MultipartFile file) {7.// 判断文件是否为空8.if (!file.isEmpty()) {9.try {10.// 文件保存路径11. String filePath = request.getSession().getServletContext().getRealPath("/") + "upload/"12. + file.getOriginalFilename();13.// 转存文件14. file.transferTo(new File(filePath));15.return true;16. } catch (Exception e) {17. e.printStackTrace();18. }19. }20.return false;21. }22.3、编写action:23.@RequestMapping("filesUpload")24.public String filesUpload(@RequestParam("files") MultipartFile[] files){25.//判断file数组不能为空并且长度大于026.if(files!=null&&files.length>0){27.//循环获取file数组中得文件28.for(int i = 0;i<files.length;i++){29. MultipartFile file = files[i];30.//保存文件31. saveFile(file);32. }33. }34.// 重定向35.return"redirect:/list.html";36. }最后运行项目上传文件:.。