@Override
protected void service(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
// Just echo the parameters and values back as plain text
resp.setContentType("text/plain");
resp.setCharacterEncoding("UTF-8");
PrintWriter out = resp.getWriter();
out.println(
"parts=" + (null == req.getParts() ? "null" : Integer.valueOf(req.getParts().size())));
}
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
HttpSession session = request.getSession();
String roomname = (String) session.getAttribute("roomname");
Logger logger = Logger.getLogger(FileUploadServlet.class);
String caminho = getServletContext().getRealPath("\\image\\");
String BASE_DIR = caminho + roomname;
response.setContentType("text/html;charset=UTF-8");
FileService service = new FileService();
Path destination = service.createFolder(BASE_DIR);
for (Part part : request.getParts()) {
if (Files.exists(destination)) {
service.saveFile(destination, part);
}
}
request.setAttribute("message", "Upload has been done successfully!");
request.setAttribute("fileEntities", service.findAll());
getServletContext().getRequestDispatcher("/file-list.jsp").forward(request, response);
}
/** prepara los archivos enviados desde el clienta para su interpretacion (maximo de cinco) */
public boolean ejecutar(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// TODO Auto-generated method stub
// leer base de datos
Collection<Part> partes = request.getParts();
@SuppressWarnings("unused")
ProcesaDAOUsuario db = new ProcesaDAOUsuario(this.ds, this.sql);
@SuppressWarnings({"unchecked", "rawtypes"})
HashMap<Archivo, String> listaarchivosubido = new HashMap();
this.Modelo = new ModeloAjax();
for (Part trozo : partes) {
if (trozo != null) {
Archivo archivo = new Archivo(getNombreArchivo(trozo), trozo.getInputStream());
if (archivo.isArchivo()) {
listaarchivosubido.put(archivo, "correcto");
} else {
listaarchivosubido.put(
archivo, "formato de archivo incorrecto(boe 105 del 3/5/2005 pag 15128)");
}
}
}
this.Modelo.setRespuesta(preparerarModelo(listaarchivosubido));
this.Modelo.setContentType("text/html; charset=UTF-8");
return true;
}
public void doPost(HttpServletRequest req, HttpServletResponse resp)
throws IOException, ServletException {
String filename = "";
Logger logger = Logger.getLogger(this.getClass().getCanonicalName());
req.setCharacterEncoding("UTF-8");
resp.setContentType("text/html;charset=UTF-8");
String path = "/home/roman/uploads";
FileWriter fw = new FileWriter("my.properties");
Properties props = new Properties();
props.setProperty("user.name", "Роман");
props.store(fw, "Some commets about this version");
fw.close();
// getServletContext().getRealPath("") + File.separator + "uploads";
PrintWriter out = resp.getWriter();
try {
Part p = req.getPart("content");
if (p != null) {
// req.getPart("content").write(path+filename);
filename = getFileName(p);
for (Part part : req.getParts()) {
logger.info("Saving parts: " + filename);
part.write(path + File.separator + filename);
}
logger.info("uploaded file: " + filename);
out.write("<h3>" + path + File.separator + filename + "</h3>");
}
} catch (IllegalStateException e) {
out.write("<h3>" + e.getMessage() + ", upload limit 5Mb</h3>");
// resp.sendError(HttpServletResponse.SC_REQUEST_ENTITY_TOO_LARGE);
}
}
/** @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response) */
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// TODO Auto-generated method stub
String appPath = request.getServletContext().getRealPath("");
String filePath = "";
for (Part part : request.getParts()) {
String fileName = extractFileName(part);
filePath = appPath + File.separator + fileName;
part.write(filePath);
System.out.println("Wrote file to " + appPath + File.separator + fileName);
}
CSVReader reader = new CSVReader(new FileReader(filePath));
String[] nextLine;
ArrayList<DataBean> data = new ArrayList<DataBean>();
while ((nextLine = reader.readNext()) != null) {
// nextLine[] is an array of values from the line
System.out.println(nextLine[0] + nextLine[1]);
DataBean bean = new DataBean();
bean.setUsername(nextLine[0]);
bean.setPassword(nextLine[1]);
data.add(bean);
}
// Remove Username,password header
data.remove(0);
request.setAttribute("data", data);
request.getRequestDispatcher("output.jsp").forward(request, response);
}
protected Properties getParams(HttpServletRequest req)
throws UnsupportedEncodingException, IOException, ServletException {
String contentType = req.getContentType();
Collection<Part> parts = null;
try {
parts = req.getParts();
} catch (Exception e) {
log.debug("Error parsing request parts " + e.getMessage());
}
if (parts != null && !parts.isEmpty()) {
Properties props = new Properties();
for (Part p : parts) {
String realContent = getContentFromPart(p);
props.put(p.getName(), realContent);
}
return props;
} else {
Properties props = null;
if (contentType.indexOf("application/x-www-form-urlencoded") >= 0) {
String result = URLDecoder.decode(getFullContent(req), encoding);
props = ParamGetter.getProps(result);
} else if (contentType.indexOf("multipart/form-data") >= 0) {
MultipartParser parser = new MultipartParser(req, MAXPARAMSIZE);
props = ParamGetter.getProps(parser);
} else {
log.error("Cannot parse contentType of " + contentType);
throw new IOException("Bad content type of " + contentType);
}
return props;
}
}
public Collection<Part> parts() {
try {
return raw.getParts();
} catch (IOException ex) {
ex.printStackTrace();
return null;
} catch (ServletException ex) {
ex.printStackTrace();
return null;
}
}
// override 'POST' handler. Appliction will use 'POST' to send 'multipart/form-data'
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
/*
* check content type. Require 'multipart/form-data' header in most case contains more than value, some parameters are
* present so make a check with String.contains(String). send 406, with error message if it does not contain proper type
*/
final String reqContentType = req.getContentType();
if (!reqContentType.contains("multipart/form-data")) {
logger.severe("Received request which is not mulipart: " + reqContentType);
resp.sendError(406, "Received request which is not mulipart: " + reqContentType);
return;
}
/*
* In servlet 3.0, Parts carry form data. Get Parts and perform some name & type checks. Parts contain all data sent in
* form not only file, we need only file.
*/
Collection<Part> fileParts = req.getParts();
if (fileParts != null && fileParts.size() > 0) {
for (Part p : fileParts) {
String partContentType = p.getContentType();
String partName = p.getName();
if (partContentType != null
&& partContentType.equals("text/xml")
&& partName != null
&& partName.equals(INPUT_NAME)) {
InputStream is = p.getInputStream();
fileUploadBean.parseUpload(is);
break;
}
}
}
/*
* Fetch dispatcher for '/'. This will make 'rd' initialized to dispatcher handling for application root.
*/
RequestDispatcher rd = getServletContext().getRequestDispatcher("/");
if (rd != null) {
/*
* Forward the request to default servlet handling calls to application root. In our case FacesServlet
*/
rd.forward(req, resp);
return;
} else {
// this is bad thing, lets throw exception to make user aware of that?
throw new IllegalStateException("Container is not well!");
}
}
private Object[] parsePost(HttpServletRequest req) throws BrijjException {
List<Object> lf = new LinkedList<Object>();
if (isMultipartContent(req)) {
try {
Collection<Part> p = req.getParts();
/*for (int i = 0; i < p.size(); i++)
lf.add(null);
*/
for (Part z : p) {
String n = z.getName();
Object o = readObject(z);
// lf.set(Integer.valueOf(z.getName().substring(1)), readObject(z));
lf.add(o);
}
return lf.toArray();
} catch (ServletException sx) {
throw new BrijjException(sx);
} catch (IOException ix) {
throw new BrijjException(ix);
}
} else {
BufferedReader in = null;
try {
String ce = req.getCharacterEncoding();
InputStream is = req.getInputStream();
InputStreamReader isr =
ce != null ? new InputStreamReader(is, ce) : new InputStreamReader(is);
in = new BufferedReader(isr);
while (true) {
String line = in.readLine();
if (line == null) return lf.toArray();
if (line.indexOf('&') == -1) lf.add(readObject(line));
// If there are any &'s then this must be iframe post
else {
StringTokenizer st = new StringTokenizer(line, "&");
while (st.hasMoreTokens()) lf.add(readObject(urlDecode(st.nextToken())));
}
}
} catch (Exception ex) {
throw new BrijjException("Failed to read input", ex);
} finally {
if (in != null)
try {
in.close();
} catch (IOException ex) {
}
}
}
}
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
HttpSession session = request.getSession();
String username = "";
for (Part part : request.getParts()) {
if (part.getName().equals("message")) {
part.delete();
break;
}
String type = part.getContentType();
if (!type.startsWith("image/")) {
request.setAttribute("invalidType", true);
RequestDispatcher rd = request.getRequestDispatcher("upload.jsp");
rd.forward(request, response);
}
String filename = part.getSubmittedFileName();
InputStream is = request.getPart(part.getName()).getInputStream();
int i = is.available();
LoggedIn lg = (LoggedIn) session.getAttribute("LoggedIn");
if (lg.getlogedin()) {
username = lg.getUsername();
if (i > 0) {
byte[] b = new byte[i + 1];
is.read(b);
PicModel tm = new PicModel();
tm.setCluster(cluster);
String description = request.getParameter("message");
if (session.getAttribute("Location").equals("profile")) {
tm.insertPic(b, type, filename, username, description, true);
} else {
tm.insertPic(b, type, filename, username, description, false);
}
is.close();
}
}
}
if (session.getAttribute("Location").equals("profile")) {
response.sendRedirect("UserProfile");
} else {
response.sendRedirect("/InstagrimXinyue/Images/" + username);
}
}
/** @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response) */
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// gets absolute path of the web application
String appPath = request.getServletContext().getRealPath("");
// constructs path of the directory to save uploaded file
String savePath = appPath + File.separator + SAVE_DIR;
String fileName = System.currentTimeMillis() + "";
// creates the save directory if it does not exists
File fileSaveDir = new File(savePath);
if (!fileSaveDir.exists()) {
fileSaveDir.mkdir();
}
for (Part part : request.getParts()) {
part.write(savePath + File.separator + fileName);
}
response.getWriter().append("{\"code\": \"" + fileName + "\"}");
}
@Override
public void decode(FacesContext context, UIComponent component) {
rendererParamsNotNull(context, component);
if (!shouldDecode(component)) {
return;
}
String clientId = decodeBehaviors(context, component);
if (clientId == null) {
clientId = component.getClientId(context);
}
assert (clientId != null);
ExternalContext externalContext = context.getExternalContext();
Map<String, String> requestMap = externalContext.getRequestParameterMap();
if (requestMap.containsKey(clientId)) {
setSubmittedValue(component, requestMap.get(clientId));
}
HttpServletRequest request = (HttpServletRequest) externalContext.getRequest();
try {
Collection<Part> parts = request.getParts();
List<Part> multiple = new ArrayList<>();
for (Part cur : parts) {
if (clientId.equals(cur.getName())) {
component.setTransient(true);
multiple.add(cur);
}
}
this.setSubmittedValue(component, multiple);
} catch (IOException | ServletException ioe) {
throw new FacesException(ioe);
}
}
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// TODO 上传一张照片,Servlet3.0支持文件上传
Collection<Part> photoList = request.getParts();
}
protected void doPost(
HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse)
throws ServletException, IOException {
// CORS ORIGIN RESPONSE HEADER
httpServletResponse.setHeader(
"Access-Control-Allow-Origin",
config.getProperty(HBNGStatics.CORS_ACCESS_CONTROL_ALLOW_ORIGIN_IDENTIFIER));
// work on headers
String authorization = "";
String contenttype = "";
Enumeration<String> headerNames = httpServletRequest.getHeaderNames();
while (headerNames.hasMoreElements()) {
String headerNameKey = headerNames.nextElement();
this.logger.debug(
"headerNameKey = "
+ headerNameKey
+ " / headerNameValue = "
+ httpServletRequest.getHeader(headerNameKey));
if (headerNameKey.equals("Authorization")) {
authorization = httpServletRequest.getHeader(headerNameKey);
}
if (headerNameKey.equals("Content-Type")) {
contenttype = httpServletRequest.getHeader(headerNameKey);
}
}
this.logger.info("contenttype = " + contenttype);
// work on parameters
String id = "";
if (httpServletRequest.getParameter("uuid") != null
&& !httpServletRequest.getParameter("uuid").equals("")) {
id = httpServletRequest.getParameter("uuid");
} else {
id = UUID.randomUUID().toString();
}
this.logger.info("ID: " + id);
// constructs path of the directory to save uploaded file
String savePath = this.config.getProperty("multipart.path.uploadedFiles") + File.separator + id;
// creates the save directory if it does not exists
File fileSaveDir = new File(this.config.getProperty("multipart.path.base") + savePath);
if (!fileSaveDir.exists()) {
this.logger.info("Verzeichnis existiert nicht! Lege '" + savePath + "' an.");
fileSaveDir.mkdir();
} else {
this.logger.info("Verzeichnis '" + savePath + "' existiert!");
}
// work on request parts
try {
String modsData = null;
String modsDataContentType = null;
String cslData = null;
String cslDataContentType = null;
HashMap<String, HashMap<String, String>> swordTasks =
new HashMap<String, HashMap<String, String>>();
boolean isTask = true;
for (Part part : httpServletRequest.getParts()) {
// new publications as file upload
if (part.getName().startsWith("file-")) {
String fileName = extractFileName(part);
this.logger.info("partname: " + part.getName() + "; filename: " + fileName);
part.write(savePath + File.separator + fileName);
// TODO create new Ticket
isTask = false;
}
// Uploads
else if (part.getName().startsWith("resource-") && part.getName().endsWith("-file")) {
String fileName = extractFileName(part);
this.logger.info("partname: " + part.getName() + "; filename: " + fileName);
part.write(savePath + File.separator + fileName);
// add to SWORD-Task
if (!swordTasks.containsKey(part.getName().split("-file")[0])) {
HashMap<String, String> swordTask = new HashMap<String, String>();
swordTask.put("file", fileName);
swordTasks.put(part.getName().split("-file")[0], swordTask);
} else {
swordTasks.get(part.getName().split("-file")[0]).put("file", fileName);
}
} else if (part.getName().startsWith("resource-") && part.getName().endsWith("-type")) {
String value =
new BufferedReader(new InputStreamReader(part.getInputStream()))
.lines()
.collect(Collectors.joining(System.lineSeparator()));
this.logger.info(part.getName() + ": " + value);
// add to SWORD-Task
if (!swordTasks.containsKey(part.getName().split("-type")[0])) {
HashMap<String, String> swordTask = new HashMap<String, String>();
swordTask.put("type", value);
swordTasks.put(part.getName().split("-type")[0], swordTask);
} else {
swordTasks.get(part.getName().split("-type")[0]).put("type", value);
}
} else if (part.getName().startsWith("resource-") && part.getName().endsWith("-note")) {
String value =
new BufferedReader(new InputStreamReader(part.getInputStream()))
.lines()
.collect(Collectors.joining(System.lineSeparator()));
this.logger.info(part.getName() + ": " + value);
// add to SWORD-Task
if (!swordTasks.containsKey(part.getName().split("-note")[0])) {
HashMap<String, String> swordTask = new HashMap<String, String>();
swordTask.put("note", value);
swordTasks.put(part.getName().split("-note")[0], swordTask);
} else {
swordTasks.get(part.getName().split("-note")[0]).put("note", value);
}
} else if (part.getName().startsWith("dataset-mods")) {
modsData =
new BufferedReader(new InputStreamReader(part.getInputStream()))
.lines()
.collect(Collectors.joining(System.lineSeparator()));
modsDataContentType = part.getContentType();
this.logger.debug(part.getName() + ": " + modsData);
} else if (part.getName().startsWith("dataset-csl")) {
cslData =
new BufferedReader(new InputStreamReader(part.getInputStream()))
.lines()
.collect(Collectors.joining(System.lineSeparator()));
cslDataContentType = part.getContentType();
this.logger.debug(part.getName() + ": " + cslData);
} else {
this.logger.info(
part.getName()
+ ": "
+ new BufferedReader(new InputStreamReader(part.getInputStream()))
.lines()
.collect(Collectors.joining(System.lineSeparator())));
}
}
String data = "";
try {
data =
httpServletRequest
.getReader()
.lines()
.collect(Collectors.joining(System.lineSeparator()));
this.logger.info("RequestBody is not empty!");
this.logger.info("data: " + data);
} catch (Exception e) {
this.logger.info("RequestBody is empty!");
}
// validate existence of modsData and its content type > SC_NO_CONTENT
if (modsData == null || modsData.equals("")) {
this.logger.error(HttpServletResponse.SC_NO_CONTENT + " - No Content");
httpServletResponse.sendError(HttpServletResponse.SC_NO_CONTENT, "No Content");
} else {
// PROCESSING
if (isTask) {
// Migrate and POST to LDP
String postableData = null;
// bind interface Preprocessing
if (Lookup.lookupAll(PreprocessingInterface.class).size() > 0) {
PreprocessingInterface preprocessingInterface =
Lookup.lookup(PreprocessingInterface.class);
// init Authorization Service
preprocessingInterface.init(this.config);
postableData = preprocessingInterface.process(modsData);
} else {
// correct error handling
this.logger.error(
"["
+ this.config.getProperty("service.name")
+ "] "
+ HttpServletResponse.SC_INTERNAL_SERVER_ERROR
+ ": "
+ "Authorization Interface not implemented!");
}
// POST MODS data to LDP
boolean isModsDataPosted = false;
if (postableData != null) {
// POST as application/sparql-update to LinkedDataPlatform
String sparql_url = this.config.getProperty("ldp.sparql-endpoint");
// HTTP Request
int timeout = Integer.parseInt(this.config.getProperty("ldp.timeout"));
RequestConfig defaultRequestConfig =
RequestConfig.custom()
.setSocketTimeout(timeout)
.setConnectTimeout(timeout)
.setConnectionRequestTimeout(timeout)
.build();
try (CloseableHttpClient httpclient =
HttpClients.custom().setDefaultRequestConfig(defaultRequestConfig).build()) {
HttpPost httpPost = new HttpPost(sparql_url);
httpPost.addHeader("Content-Type", "application/sparql-update");
httpPost.addHeader("Authorization", this.config.getProperty("ldp.authorization"));
httpPost.setEntity(new StringEntity(postableData));
CloseableHttpResponse httpResponse = null;
long start = System.nanoTime();
try {
httpResponse = httpclient.execute(httpPost);
} catch (ConnectTimeoutException | SocketTimeoutException e) {
this.logger.info(
"["
+ this.getClass().getName()
+ "] "
+ e.getClass().getName()
+ ": "
+ e.getMessage());
httpResponse = httpclient.execute(httpPost);
}
long elapsed = System.nanoTime() - start;
this.logger.info(
"["
+ this.getClass().getName()
+ "] LDP request - "
+ (elapsed / 1000.0 / 1000.0 / 1000.0)
+ " s");
try {
int statusCode = httpResponse.getStatusLine().getStatusCode();
HttpEntity httpEntity = httpResponse.getEntity();
if (statusCode == 200 || statusCode == 201) {
isModsDataPosted = true;
} else {
this.logger.error(
"POST to LDP failed! - "
+ statusCode
+ ": "
+ httpResponse.getStatusLine().getReasonPhrase());
}
EntityUtils.consume(httpEntity);
} finally {
httpResponse.close();
}
}
}
if (isModsDataPosted) {
// TODO work on CSL data
// TODO work on SWORD-Tasks
// Interface Repository with implementation for SWORD using
// https://github.com/swordapp/JavaClient2.0
if (swordTasks.size() > 0) {
for (String taskid : swordTasks.keySet()) {
System.out.println("TASK: '" + taskid + "'");
System.out.println("type: " + swordTasks.get(taskid).get("type"));
System.out.println(
"file: "
+ this.config.getProperty("multipart.path.base")
+ savePath
+ File.separator
+ swordTasks.get(taskid).get("file"));
System.out.println("note: " + swordTasks.get(taskid).get("note"));
// TODO Was passiert mit den MODS- und ggf. CSL-Daten, wenn das hier schiefgeht?
// 1. Möglichkeit: Lösche MODS und CSL und geben 500 zurück
// 2. Möglichkeit: Kopiere die Dateien in ein "manuell bearbeiten"-Verzeichnis und
// sende 201
// Mein Favorit: 2. Möglichkeit
}
}
}
// last but not least: delete 'uploadFiles'-subfolder
deleteTree(new File(this.config.getProperty("multipart.path.base") + savePath));
}
}
// response
httpServletResponse.setStatus(HttpServletResponse.SC_CREATED);
httpServletResponse.getWriter().println("");
} catch (Exception e) {
this.logger.error("something went wrong", e);
httpServletResponse.sendError(
HttpServletResponse.SC_SERVICE_UNAVAILABLE, "something went wrong");
}
}
public void doUpload(HttpServletRequest request, HttpServletResponse response)
throws IOException, ServletException {
if (!common.checkPost(request, response)) return;
User user = common.requireLoggedInUser(request, response);
if (user == null) return;
DbxClient dbxClient = requireDbxClient(request, response, user);
if (dbxClient == null) return;
try {
request.getParts(); // Just call getParts() to trigger the too-large exception.
} catch (IllegalStateException ex) {
response.sendError(400, "Request too large");
return;
}
String targetFolder = slurpUtf8Part(request, response, "targetFolder", 1024);
if (targetFolder == null) return;
Part filePart = request.getPart("file");
if (filePart == null) {
response.sendError(400, "Field \"file\" is missing.");
return;
}
String fileName = filePart.getName();
if (fileName == null) {
response.sendError(400, "Field \"file\" has no name.");
return;
}
// Upload file to Dropbox
String fullTargetPath = targetFolder + "/" + fileName;
DbxEntry.File metadata;
try {
metadata =
dbxClient.uploadFile(
fullTargetPath, DbxWriteMode.add(), filePart.getSize(), filePart.getInputStream());
} catch (DbxException ex) {
common.handleDbxException(response, user, ex, "uploadFile(" + jq(fullTargetPath) + ", ...)");
return;
} catch (IOException ex) {
response.sendError(400, "Error getting file data from you.");
return;
}
// Display uploaded file metadata.
response.setContentType("text/html");
response.setCharacterEncoding("utf-8");
PrintWriter out = new PrintWriter(new OutputStreamWriter(response.getOutputStream(), "UTF-8"));
out.println("<html>");
out.println("<head><title>File uploaded: " + escapeHtml4(metadata.path) + "</title></head>");
out.println("<body>");
out.println("<h2>File uploaded: " + escapeHtml4(metadata.path) + "</h2>");
out.println("<pre>");
out.print(escapeHtml4(metadata.toStringMultiline()));
out.println("</pre>");
out.println("</body>");
out.println("</html>");
out.flush();
}
@Override
public Collection<Part> getParts() throws IOException, IllegalStateException, ServletException {
return request.getParts();
}
public static Object resolvePart(HttpServletRequest servletRequest) throws Exception {
Collection<Part> parts = servletRequest.getParts();
return parts.toArray(new Part[parts.size()]);
}
@Override
public Object resolveArgument(
MethodParameter parameter,
ModelAndViewContainer mavContainer,
NativeWebRequest request,
WebDataBinderFactory binderFactory)
throws Exception {
HttpServletRequest servletRequest = request.getNativeRequest(HttpServletRequest.class);
assertIsMultipartRequest(servletRequest);
MultipartHttpServletRequest multipartRequest =
WebUtils.getNativeRequest(servletRequest, MultipartHttpServletRequest.class);
String partName = getPartName(parameter);
Object arg;
if (MultipartFile.class.equals(parameter.getParameterType())) {
Assert.notNull(
multipartRequest,
"Expected MultipartHttpServletRequest: is a MultipartResolver configured?");
arg = multipartRequest.getFile(partName);
} else if (isMultipartFileCollection(parameter)) {
Assert.notNull(
multipartRequest,
"Expected MultipartHttpServletRequest: is a MultipartResolver configured?");
arg = multipartRequest.getFiles(partName);
} else if (isMultipartFileArray(parameter)) {
Assert.notNull(
multipartRequest,
"Expected MultipartHttpServletRequest: is a MultipartResolver configured?");
List<MultipartFile> files = multipartRequest.getFiles(partName);
arg = files.toArray(new MultipartFile[files.size()]);
} else if ("javax.servlet.http.Part".equals(parameter.getParameterType().getName())) {
assertIsMultipartRequest(servletRequest);
arg = servletRequest.getPart(partName);
} else if (isPartCollection(parameter)) {
assertIsMultipartRequest(servletRequest);
arg = new ArrayList<Object>(servletRequest.getParts());
} else if (isPartArray(parameter)) {
assertIsMultipartRequest(servletRequest);
arg = RequestPartResolver.resolvePart(servletRequest);
} else {
try {
HttpInputMessage inputMessage =
new RequestPartServletServerHttpRequest(servletRequest, partName);
arg = readWithMessageConverters(inputMessage, parameter, parameter.getParameterType());
WebDataBinder binder = binderFactory.createBinder(request, arg, partName);
if (arg != null) {
validate(binder, parameter);
}
mavContainer.addAttribute(
BindingResult.MODEL_KEY_PREFIX + partName, binder.getBindingResult());
} catch (MissingServletRequestPartException ex) {
// handled below
arg = null;
}
}
RequestPart annot = parameter.getParameterAnnotation(RequestPart.class);
boolean isRequired = (annot == null || annot.required());
if (arg == null && isRequired) {
throw new MissingServletRequestPartException(partName);
}
return arg;
}