org.frameworkset.http.converter.FormHttpMessageConverter Maven / Gradle / Ivy
Show all versions of bboss-mvc Show documentation
/*
* Copyright 2008-2010 biaoping.yin
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.frameworkset.http.converter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Random;
import javax.servlet.http.HttpServletResponse;
import org.frameworkset.http.HttpEntity;
import org.frameworkset.http.HttpHeaders;
import org.frameworkset.http.HttpInputMessage;
import org.frameworkset.http.HttpOutputMessage;
import org.frameworkset.http.MediaType;
import org.frameworkset.util.Assert;
import org.frameworkset.util.FileCopyUtils;
import org.frameworkset.util.LinkedMultiValueMap;
import org.frameworkset.util.MultiValueMap;
import org.frameworkset.util.io.Resource;
import org.frameworkset.web.util.WebUtils;
import com.frameworkset.util.StringUtil;
/**
* Implementation of {@link HttpMessageConverter} that can handle form data, including multipart form data
* (i.e. file uploads).
*
* This converter can write the {@code application/x-www-form-urlencoded} and {@code multipart/form-data} media
* types, and read the {@code application/x-www-form-urlencoded}) media type (but not {@code multipart/form-data}).
*
*
In other words, this converter can read and write 'normal' HTML forms (as
* {@link MultiValueMap MultiValueMap<String, String>}), and it can write multipart form (as
* {@link MultiValueMap MultiValueMap<String, Object>}. When writing multipart, this converter uses other
* {@link HttpMessageConverter HttpMessageConverters} to write the respective MIME parts. By default, basic converters
* are registered (supporting {@code Strings} and {@code Resources}, for instance); these can be overridden by setting
* the {@link #setPartConverters(java.util.List) partConverters} property.
*
*
For example, the following snippet shows how to submit an HTML form:
*
* RestTemplate template = new RestTemplate(); // FormHttpMessageConverter is configured by default
* MultiValueMap<String, String> form = new LinkedMultiValueMap<String, String>();
* form.add("field 1", "value 1");
* form.add("field 2", "value 2");
* form.add("field 2", "value 3");
* template.postForLocation("http://example.com/myForm", form);
*
* The following snippet shows how to do a file upload:
*
* MultiValueMap<String, Object> parts = new LinkedMultiValueMap<String, Object>();
* parts.add("field 1", "value 1");
* parts.add("file", new ClassPathResource("myFile.jpg"));
* template.postForLocation("http://example.com/myFileUpload", parts);
*
*
* Some methods in this class were inspired by {@link org.apache.commons.httpclient.methods.multipart.MultipartRequestEntity}.
*
* @author Arjen Poutsma
* @see MultiValueMap
* @since 3.0
*/
public class FormHttpMessageConverter implements HttpMessageConverter> {
private static final byte[] BOUNDARY_CHARS =
new byte[]{'-', '_', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', 'a', 'b', 'c', 'd', 'e', 'f', 'g',
'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'A',
'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U',
'V', 'W', 'X', 'Y', 'Z'};
private final Random rnd = new Random();
private Charset charset = Charset.forName(WebUtils.DEFAULT_CHARACTER_ENCODING);
private List> partConverters = new ArrayList>();
public FormHttpMessageConverter() {
this.partConverters.add(new ByteArrayHttpMessageConverter());
StringHttpMessageConverter stringHttpMessageConverter = new StringHttpMessageConverter();
stringHttpMessageConverter.setWriteAcceptCharset(false);
this.partConverters.add(stringHttpMessageConverter);
this.partConverters.add(new ResourceHttpMessageConverter());
}
/**
* Add a message body converter. Such a converters is used to convert objects to MIME parts.
*/
public final void addPartConverter(HttpMessageConverter partConverter) {
Assert.notNull(partConverter, "'partConverter' must not be NULL");
this.partConverters.add(partConverter);
}
/**
* Set the message body converters to use. These converters are used to convert objects to MIME parts.
*/
public final void setPartConverters(List> partConverters) {
Assert.notEmpty(partConverters, "'partConverters' must not be empty");
this.partConverters = partConverters;
}
/**
* Sets the character set used for writing form data.
*/
public void setCharset(Charset charset) {
this.charset = charset;
}
@Override
public boolean isdefault() {
// TODO Auto-generated method stub
return false;
}
public boolean canRead(Class clazz, MediaType mediaType) {
if (!MultiValueMap.class.isAssignableFrom(clazz)) {
return false;
}
if (mediaType != null) {
return MediaType.APPLICATION_FORM_URLENCODED.includes(mediaType);
}
else {
return true;
}
}
public boolean canWrite(Class clazz, MediaType mediaType) {
if (!MultiValueMap.class.isAssignableFrom(clazz)) {
return false;
}
if (mediaType != null) {
return mediaType.isCompatibleWith(MediaType.APPLICATION_FORM_URLENCODED) ||
mediaType.isCompatibleWith(MediaType.MULTIPART_FORM_DATA);
}
else {
return true;
}
}
public List getSupportedMediaTypes() {
return Arrays.asList(MediaType.APPLICATION_FORM_URLENCODED, MediaType.MULTIPART_FORM_DATA);
}
public MultiValueMap read(Class> clazz,
HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException {
MediaType contentType = inputMessage.getHeaders().getContentType();
Charset charset = contentType.getCharSet() != null ? contentType.getCharSet() : this.charset;
String body = FileCopyUtils.copyToString(new InputStreamReader(inputMessage.getBody(), charset));
String[] pairs = StringUtil.tokenizeToStringArray(body, "&");
MultiValueMap result = new LinkedMultiValueMap(pairs.length);
for (String pair : pairs) {
int idx = pair.indexOf('=');
if (idx == -1) {
result.add(URLDecoder.decode(pair, charset.name()), null);
}
else {
String name = URLDecoder.decode(pair.substring(0, idx), charset.name());
String value = URLDecoder.decode(pair.substring(idx + 1), charset.name());
result.add(name, value);
}
}
return result;
}
@SuppressWarnings("unchecked")
public void write(MultiValueMap map, MediaType contentType, HttpOutputMessage outputMessage,HttpInputMessage inputMessage )
throws IOException, HttpMessageNotWritableException {
if (!isMultipart(map, contentType)) {
writeForm((MultiValueMap) map, outputMessage);
}
else {
writeMultipart((MultiValueMap) map, outputMessage, inputMessage);
}
}
private boolean isMultipart(MultiValueMap map, MediaType contentType) {
if (contentType != null) {
return MediaType.MULTIPART_FORM_DATA.equals(contentType);
}
for (String name : map.keySet()) {
for (Object value : map.get(name)) {
if (value != null && !(value instanceof String)) {
return true;
}
}
}
return false;
}
private void writeForm(MultiValueMap form, HttpOutputMessage outputMessage) throws IOException {
outputMessage.getHeaders().setContentType(MediaType.APPLICATION_FORM_URLENCODED);
StringBuilder builder = new StringBuilder();
for (Iterator nameIterator = form.keySet().iterator(); nameIterator.hasNext();) {
String name = nameIterator.next();
for (Iterator valueIterator = form.get(name).iterator(); valueIterator.hasNext();) {
String value = valueIterator.next();
builder.append(URLEncoder.encode(name, charset.name()));
if (value != null) {
builder.append('=');
builder.append(URLEncoder.encode(value, charset.name()));
if (valueIterator.hasNext()) {
builder.append('&');
}
}
}
if (nameIterator.hasNext()) {
builder.append('&');
}
}
FileCopyUtils.copy(builder.toString(), new OutputStreamWriter(outputMessage.getBody(), charset));
}
private void writeMultipart(MultiValueMap parts, HttpOutputMessage outputMessage,HttpInputMessage inputMessage) throws IOException {
byte[] boundary = generateMultipartBoundary();
Map parameters = Collections.singletonMap("boundary", new String(boundary, "US-ASCII"));
MediaType contentType = new MediaType(MediaType.MULTIPART_FORM_DATA, parameters);
outputMessage.getHeaders().setContentType(contentType);
writeParts(outputMessage.getBody(), parts, boundary, inputMessage);
writeEnd(boundary, outputMessage.getBody());
}
private void writeParts(OutputStream os, MultiValueMap parts, byte[] boundary,HttpInputMessage inputMessage) throws IOException {
for (Map.Entry> entry : parts.entrySet()) {
String name = entry.getKey();
for (Object part : entry.getValue()) {
writeBoundary(boundary, os);
HttpEntity entity = getEntity(part);
writePart(name, entity, os, inputMessage);
writeNewLine(os);
}
}
}
private void writeBoundary(byte[] boundary, OutputStream os) throws IOException {
os.write('-');
os.write('-');
os.write(boundary);
writeNewLine(os);
}
@SuppressWarnings("unchecked")
private HttpEntity getEntity(Object part) {
if (part instanceof HttpEntity) {
return (HttpEntity) part;
}
else {
return new HttpEntity(part);
}
}
@SuppressWarnings("unchecked")
private void writePart(String name, HttpEntity partEntity, OutputStream os,HttpInputMessage inputMessage) throws IOException {
Object partBody = partEntity.getBody();
Class partType = partBody.getClass();
HttpHeaders partHeaders = partEntity.getHeaders();
MediaType partContentType = partHeaders.getContentType();
for (HttpMessageConverter messageConverter : partConverters) {
if (messageConverter.canWrite( partType, partContentType)) {
HttpOutputMessage multipartOutputMessage = new MultipartHttpOutputMessage(os,null);
multipartOutputMessage.getHeaders().setContentDispositionFormData(name, getFilename(partBody));
if (!partHeaders.isEmpty()) {
multipartOutputMessage.getHeaders().putAll(partHeaders);
}
messageConverter.write(partBody, partContentType, multipartOutputMessage, inputMessage);
return;
}
}
throw new HttpMessageNotWritableException(
"Could not write request: no suitable HttpMessageConverter found for request type [" +
partType.getName() + "]");
}
private void writeEnd(byte[] boundary, OutputStream os) throws IOException {
os.write('-');
os.write('-');
os.write(boundary);
os.write('-');
os.write('-');
writeNewLine(os);
}
private void writeNewLine(OutputStream os) throws IOException {
os.write('\r');
os.write('\n');
}
/**
* Generate a multipart boundary.
* Default implementation returns a random boundary. Can be overridden in subclasses.
*/
protected byte[] generateMultipartBoundary() {
byte[] boundary = new byte[rnd.nextInt(11) + 30];
for (int i = 0; i < boundary.length; i++) {
boundary[i] = BOUNDARY_CHARS[rnd.nextInt(BOUNDARY_CHARS.length)];
}
return boundary;
}
/**
* Return the filename of the given multipart part. This value will be used for the {@code Content-Disposition} header.
*
Default implementation returns {@link Resource#getFilename()} if the part is a {@code Resource}, and
* {@code null} in other cases. Can be overridden in subclasses.
* @param part the part to determine the file name for
* @return the filename, or {@code null} if not known
*/
protected String getFilename(Object part) {
if (part instanceof Resource) {
Resource resource = (Resource) part;
return resource.getFilename();
}
else {
return null;
}
}
/**
* Implementation of {@link HttpOutputMessage} used for writing multipart data.
*/
private class MultipartHttpOutputMessage implements HttpOutputMessage {
private HttpServletResponse response;
private final HttpHeaders headers = new HttpHeaders();
private final OutputStream os;
private boolean headersWritten = false;
public MultipartHttpOutputMessage(OutputStream os,HttpServletResponse response) {
this.os = os;
this.response = response;
}
public HttpHeaders getHeaders() {
return headersWritten ? HttpHeaders.readOnlyHttpHeaders(headers) : this.headers;
}
public OutputStream getBody() throws IOException {
writeHeaders();
return this.os;
}
private void writeHeaders() throws IOException {
if (!this.headersWritten) {
for (Map.Entry> entry : this.headers.entrySet()) {
byte[] headerName = getAsciiBytes(entry.getKey());
for (String headerValueString : entry.getValue()) {
byte[] headerValue = getAsciiBytes(headerValueString);
os.write(headerName);
os.write(':');
os.write(' ');
os.write(headerValue);
writeNewLine(os);
}
}
writeNewLine(os);
this.headersWritten = true;
}
}
protected byte[] getAsciiBytes(String name) {
try {
return name.getBytes("US-ASCII");
}
catch (UnsupportedEncodingException ex) {
// should not happen, US-ASCII is always supported
throw new IllegalStateException(ex);
}
}
public HttpServletResponse getResponse()
{
// TODO Auto-generated method stub
return response;
}
}
protected MediaType defaultAcceptedMediaType;
public MediaType getDefaultAcceptedMediaType()
{
if(defaultAcceptedMediaType != null)
return defaultAcceptedMediaType;
synchronized(this){
return defaultAcceptedMediaType = this.getSupportedMediaTypes().get(0);
}
}
/**
* 获取用户请求报文对应的数据类型：String,json
* @return
*/
public String getRequetBodyDataType()
{
return null;
}
public boolean canRead(String datatype)
{
return false;
}
public String getResponseBodyDataType()
{
return null;
}
public boolean canWrite(String datatype) {
// TODO Auto-generated method stub
return false;
}
}