下面列出了javax.servlet.http.HttpServletRequest#getInputStream() 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
public static String readStrFromInputStream(HttpServletRequest request){
// 从request中取得输入流
StringBuffer sbf = new StringBuffer();
try {
InputStream inputStream = request.getInputStream();
BufferedReader in = new BufferedReader(new InputStreamReader(inputStream,"UTF-8"));
char[] bufferChar = new char[1024];
int index = 0;
while((index=in.read(bufferChar))!=-1){
sbf.append(bufferChar,0,index);
}
inputStream.close();
inputStream =null;
return sbf.toString();
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
resp.setContentType("text/plain");
resp.setCharacterEncoding("UTF-8");
// Non-blocking IO requires async
AsyncContext ac = req.startAsync();
// Use a single listener for read and write. Listeners often need to
// share state to coordinate reads and writes and this is much easier as
// a single object.
@SuppressWarnings("unused")
NumberWriterListener listener = new NumberWriterListener(
ac, req.getInputStream(), resp.getOutputStream());
}
/**
* 从request的inputStream中获取参数
* code come from https://github.com/mengday/springboot-pay-example/blob/master/src/main/java/com/example/pay/configuration/WXPayClient.java
* @param request
* @return
* @throws Exception
*/
public static Map<String, String> getNotifyParameter(HttpServletRequest request) throws Exception {
InputStream inputStream = request.getInputStream();
ByteArrayOutputStream outSteam = new ByteArrayOutputStream();
byte[] buffer = new byte[1024];
int length = 0;
while ((length = inputStream.read(buffer)) != -1) {
outSteam.write(buffer, 0, length);
}
outSteam.close();
inputStream.close();
// 获取微信调用我们notify_url的返回信息
String resultXml = new String(outSteam.toByteArray(), "utf-8");
Map<String, String> notifyMap = WXPayUtil.xmlToMap(resultXml);
return notifyMap;
}
@Override
public void doGet(HttpServletRequest request,
HttpServletResponse response
) throws ServletException, IOException {
InputStreamReader in = new InputStreamReader(request.getInputStream());
PrintStream out = new PrintStream(response.getOutputStream());
calledTimes++;
try {
requestUri = new URI(null, null,
request.getRequestURI(), request.getQueryString(), null);
} catch (URISyntaxException e) {
}
in.close();
out.close();
}
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
try (InputStream is = req.getInputStream();
InputStreamReader isr = new InputStreamReader(is);
BufferedReader br = new BufferedReader(isr)) {
String requestBody = br.lines().collect(Collectors.joining());
log.info("request body: {}", requestBody);
}
String endpoint = req.getRequestURI().replaceFirst("^/api/", "");
String body = reader.readWholeAsString(endpoint + ".json");
body = body.replaceFirst("\"ok\": false,", "\"ok\": true,");
if (body == null || body.trim().isEmpty()) {
resp.setStatus(400);
return;
}
resp.setStatus(200);
resp.getWriter().write(body);
resp.setContentType("application/json");
}
private void handle(HttpServletRequest req, HttpServletResponse resp) throws IOException {
try (InputStream is = req.getInputStream();
InputStreamReader isr = new InputStreamReader(is);
BufferedReader br = new BufferedReader(isr)) {
String requestBody = br.lines().collect(Collectors.joining());
log.info("request body: {}", requestBody);
}
String endpoint = req.getRequestURI().replaceFirst("^/api/", "");
String body = reader.readWholeAsString(endpoint + ".json");
body = body.replaceFirst("\"ok\": false,", "\"ok\": true,");
if (body == null || body.trim().isEmpty()) {
resp.setStatus(400);
return;
}
resp.setStatus(200);
resp.getWriter().write(body);
resp.setContentType("application/json");
}
public FakeRequest(HttpServletRequest request)
throws IOException {
super(request);
InputStream is = request.getInputStream();
ByteArrayOutputStream baos = new ByteArrayOutputStream();
copyStream(is, baos);
System.out.println(new String(baos.toByteArray()));
this.bytes = baos.toByteArray();
}
@Override
protected ServerResponse processRequest(HttpServletRequest request) {
InputStream inputStream;
try {
inputStream = request.getInputStream();
} catch (IOException e) {
throw new UncheckedIOException(e);
}
ServerPublicKeyCredentialGetOptionsRequest serverRequest =
objectConverter.getJsonConverter().readValue(inputStream, ServerPublicKeyCredentialGetOptionsRequest.class);
String username = serverRequest.getUsername();
Challenge challenge = serverEndpointFilterUtil.encodeUserVerification(new DefaultChallenge(), serverRequest.getUserVerification());
AssertionOptions options = optionsProvider.getAssertionOptions(request, username, challenge);
List<ServerPublicKeyCredentialDescriptor> credentials = options.getCredentials().stream().map(ServerPublicKeyCredentialDescriptor::new).collect(Collectors.toList());
AuthenticationExtensionsClientInputs<AuthenticationExtensionClientInput<?>> authenticationExtensionsClientInputs;
if (serverRequest.getExtensions() != null) {
authenticationExtensionsClientInputs = serverRequest.getExtensions();
} else {
authenticationExtensionsClientInputs = options.getAuthenticationExtensions();
}
return new ServerPublicKeyCredentialGetOptionsResponse(
Base64UrlUtil.encodeToString(options.getChallenge().getValue()),
options.getAuthenticationTimeout(),
options.getRpId(),
credentials,
serverRequest.getUserVerification(),
authenticationExtensionsClientInputs);
}
@Override
public void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 获取请求资源
String proName = req.getServletContext().getContextPath();
String requestSource = req.getRequestURI();
requestSource = requestSource.substring(requestSource.indexOf(proName) + proName.length());
if (requestSource.startsWith("/es")) {
requestSource = requestSource.substring(3);
}
/**
* get url
*/
Map<String, ConnectionFailoverMgr> connectionMgrPool = EsResource.getConnMgr();
String forwarUrl = connectionMgrPool.get("es.info.forwar.url").getConnection() + requestSource;
/**
* get method
*/
String method = req.getMethod();
/**
* get body
*/
ServletInputStream input = req.getInputStream();
EsResource.getHttpAsyncClient().doAsyncHttpMethodWithReqAsync(method, forwarUrl, null, input, null, null,
"application/json", "utf-8", new EsRestServletCallBack(), req);
}
@RequestMapping(path = "/read-byte", produces = TEXT_PLAIN_VALUE)
public void readByte(final HttpServletRequest request, final HttpServletResponse response) throws IOException {
final ServletInputStream input = request.getInputStream();
final ServletOutputStream output = response.getOutputStream();
while (true) {
final int read = input.read();
if (read == -1) {
break;
}
output.write(read);
}
}
@Override
public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) {
InputStream inputStream;
try {
inputStream = request.getInputStream();
} catch (IOException e) {
throw new UncheckedIOException(e);
}
ServerPublicKeyCredential<ServerAuthenticatorAssertionResponse> credential =
jsonConverter.readValue(inputStream, credentialTypeRef);
serverPublicKeyCredentialValidator.validate(credential);
ServerAuthenticatorAssertionResponse assertionResponse = credential.getResponse();
ServerProperty serverProperty = serverPropertyProvider.provide(request);
CollectedClientData collectedClientData = collectedClientDataConverter.convert(assertionResponse.getClientDataJSON());
UserVerificationRequirement userVerificationRequirement = serverEndpointFilterUtil.decodeUserVerification(collectedClientData.getChallenge());
WebAuthnAuthenticationRequest webAuthnAuthenticationRequest = new WebAuthnAuthenticationRequest(
Base64UrlUtil.decode(credential.getRawId()),
Base64UrlUtil.decode(assertionResponse.getClientDataJSON()),
Base64UrlUtil.decode(assertionResponse.getAuthenticatorData()),
Base64UrlUtil.decode(assertionResponse.getSignature()),
credential.getClientExtensionResults(),
serverProperty,
userVerificationRequirement == UserVerificationRequirement.REQUIRED,
false,
expectedAuthenticationExtensionIds
);
WebAuthnAssertionAuthenticationToken authRequest = new WebAuthnAssertionAuthenticationToken(webAuthnAuthenticationRequest);
setDetails(request, authRequest);
return this.getAuthenticationManager().authenticate(authRequest);
}
@Override
protected void doFilterInternal(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, FilterChain filterChain) throws ServletException, IOException {
System.out.println("IN PrintRequestContentFilter ");
InputStream inputStream = httpServletRequest.getInputStream();
byte[] body = StreamUtils.copyToByteArray(inputStream);
System.out.println("In PrintRequestContentFilter. Request body is: " + new String(body));
filterChain.doFilter(httpServletRequest, httpServletResponse);
}
protected String getRequestString(HttpServletRequest req) {
String result = "";
InputStream xml = null;
try {
xml = req.getInputStream();
StringWriter writer = new StringWriter();
IOUtils.copy(xml, writer, "UTF-8");
result = writer.toString();
} catch (IOException e) {
LOG.error("Exception reading request: ", e);
}
return result;
}
@Override
public void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
ServletInputStream inputStream = request.getInputStream();
if (inputStream != null) {
inputStream.mark(Integer.MAX_VALUE);
}
try {
String pathInfo = request.getPathInfo();
if (pathInfo.startsWith(PATH_PING)) {
ping(request, pathInfo, response);
} else if (pathInfo.startsWith(PATH_COUNTER)) {
stats.incQueryRequestCount();
getCounters(request, pathInfo, response);
} else if (pathInfo.startsWith(PATH_METRICGROUP)) {
stats.incQueryRequestCount();
getMetrics(request, pathInfo, response);
} else {
stats.incInvalidRequestCount();
response.setStatus(HttpServletResponse.SC_NOT_FOUND);
}
} catch (Throwable ex) {
String requestTxt = readRequest(request);
stats.setLastFailedRequest(readRequestHead(request) + requestTxt);
stats.registerError(ex);
response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
}finally{
response.addHeader("Access-Control-Allow-Origin", "*");
response.addHeader("Access-Control-Allow-Methods", "*");
response.addHeader("Access-Control-Allow-Headers", "Content-Type");
}
}
public BodyReaderHttpServletRequestWrapper(final HttpServletRequest request)
throws IOException {
super(request);
try (InputStream inputStream = request.getInputStream()) {
body = ByteStreams.toByteArray(inputStream);
}
}
@Override
@SuppressWarnings("unchecked")
public final void doPost(final HttpServletRequest req,
final HttpServletResponse resp)
throws IOException {
// Validating unique subscription token before processing the message
String subscriptionToken = System.getProperty(
Constants.BASE_PACKAGE + ".subscriptionUniqueToken");
if (!subscriptionToken.equals(req.getParameter("token"))) {
resp.setStatus(HttpServletResponse.SC_BAD_REQUEST);
resp.getWriter().close();
return;
}
ServletInputStream inputStream = req.getInputStream();
// Parse the JSON message to the POJO model class
JsonParser parser = JacksonFactory.getDefaultInstance()
.createJsonParser(inputStream);
parser.skipToKey("message");
PubsubMessage message = parser.parseAndClose(PubsubMessage.class);
// Store the message in the datastore
Entity messageToStore = new Entity("PubsubMessage");
messageToStore.setProperty("message",
new String(message.decodeData(), "UTF-8"));
messageToStore.setProperty("receipt-time", System.currentTimeMillis());
DatastoreService datastore =
DatastoreServiceFactory.getDatastoreService();
datastore.put(messageToStore);
// Invalidate the cache
MemcacheService memcacheService =
MemcacheServiceFactory.getMemcacheService();
memcacheService.delete(Constants.MESSAGE_CACHE_KEY);
// Acknowledge the message by returning a success code
resp.setStatus(HttpServletResponse.SC_OK);
resp.getWriter().close();
}
/**
* Gets an uncompressed {@link InputStream} for the request. If the request specifies gzip
* encoding, tries to wrap the request input stream in a {@link GZIPInputStream}. If the input
* stream does not start with a gzip header, then a stream representing a plaintext request is
* returned.
*/
public static InputStream getRequestInputStream(HttpServletRequest request) throws IOException {
InputStream bodyStream = request.getInputStream();
if (bodyStream != null && GZIP_ENCODING.equals(request.getHeader(HEADER_CONTENT_ENCODING))) {
PushbackInputStream pushbackStream = new PushbackInputStream(bodyStream, 2);
byte[] header = new byte[2];
int len = pushbackStream.read(header);
if (len > 0) {
pushbackStream.unread(header, 0, len);
}
return isGzipHeader(header) ? new GZIPInputStream(pushbackStream) : pushbackStream;
}
return bodyStream;
}
/**
* 修改用户头像C
*
* @param request HttpServletRequest
* @throws IOException
*/
@ResponseBody
@RequestMapping("/change-portrait")
public Map<String, Object> changePortrait(HttpServletRequest request) throws IOException {
//获取当前用户
User entity = SystemVariableUtils.getSessionVariable().getUser();
Map<String, Object> result = Maps.newHashMap();
//获取传进来的流
InputStream is = request.getInputStream();
//读取流内容到ByteArrayOutputStream中
ByteArrayOutputStream bytestream = new ByteArrayOutputStream();
int ch;
while ((ch = is.read()) != -1) {
bytestream.write(ch);
}
bytestream.close();
File uploadDirectory = new File(fileUploadPath);
//如果没有创建上传文件夹就创建文件夹
if (!uploadDirectory.exists() || !uploadDirectory.isDirectory()) {
uploadDirectory.mkdirs();
}
entity.setPortrait(fileUploadPath + entity.getId());
File portraitFile = new File(fileUploadPath + entity.getId());
//如果当前用户没有创建头像,就创建头像
if (!portraitFile.exists()) {
portraitFile.createNewFile();
}
//拷贝到指定路径里
FileUtils.writeByteArrayToFile(portraitFile, bytestream.toByteArray());
accountManager.updateUser(entity);
SystemVariableUtils.getSessionVariable().setUser(entity);
//设置状态值,让FaustCplus再次触发jsfunc的js函数
result.put("status","success");
return result;
}
@Override
public Object getValue(HttpServletRequest request) throws Exception {
Object body = request.getAttribute(RestConst.BODY_PARAMETER);
if (body != null) {
return convertValue(body, targetType);
}
// edge support convert from form-data or x-www-form-urlencoded to json automatically
String contentType = request.getContentType();
contentType = contentType == null ? "" : contentType.toLowerCase(Locale.US);
if (contentType.startsWith(MediaType.MULTIPART_FORM_DATA)
|| contentType.startsWith(MediaType.APPLICATION_FORM_URLENCODED)) {
return convertValue(request.getParameterMap(), targetType);
}
// for standard HttpServletRequest, getInputStream will never return null
// but for mocked HttpServletRequest, maybe get a null
// like org.apache.servicecomb.provider.springmvc.reference.ClientToHttpServletRequest
InputStream inputStream = request.getInputStream();
if (inputStream == null) {
return null;
}
if (!contentType.isEmpty() && !contentType.startsWith(MediaType.APPLICATION_JSON)) {
// TODO: we should consider body encoding
return IOUtils.toString(inputStream, StandardCharsets.UTF_8);
}
try {
ObjectReader reader = serialViewClass != null
? RestObjectMapperFactory.getRestObjectMapper().readerWithView(serialViewClass)
: RestObjectMapperFactory.getRestObjectMapper().reader();
if (decodeAsObject) {
return reader.forType(OBJECT_TYPE).readValue(inputStream);
}
return reader.forType(targetType == null ? OBJECT_TYPE : targetType)
.readValue(inputStream);
} catch (MismatchedInputException e) {
// there is no way to detect InputStream is empty, so have to catch the exception
if (!isRequired && e.getMessage().contains("No content to map due to end-of-input")) {
LOGGER.info("Empty content and required is false, taken as null");
return null;
}
throw e;
}
}
/**
* Resolves standard method arguments. The default implementation handles {@link NativeWebRequest},
* {@link ServletRequest}, {@link ServletResponse}, {@link HttpSession}, {@link Principal},
* {@link Locale}, request {@link InputStream}, request {@link Reader}, response {@link OutputStream},
* response {@link Writer}, and the given {@code thrownException}.
* @param parameterType the method parameter type
* @param webRequest the request
* @param thrownException the exception thrown
* @return the argument value, or {@link WebArgumentResolver#UNRESOLVED}
*/
protected Object resolveStandardArgument(Class<?> parameterType, NativeWebRequest webRequest,
Exception thrownException) throws Exception {
if (parameterType.isInstance(thrownException)) {
return thrownException;
}
else if (WebRequest.class.isAssignableFrom(parameterType)) {
return webRequest;
}
HttpServletRequest request = webRequest.getNativeRequest(HttpServletRequest.class);
HttpServletResponse response = webRequest.getNativeResponse(HttpServletResponse.class);
if (ServletRequest.class.isAssignableFrom(parameterType)) {
return request;
}
else if (ServletResponse.class.isAssignableFrom(parameterType)) {
return response;
}
else if (HttpSession.class.isAssignableFrom(parameterType)) {
return request.getSession();
}
else if (Principal.class.isAssignableFrom(parameterType)) {
return request.getUserPrincipal();
}
else if (Locale.class == parameterType) {
return RequestContextUtils.getLocale(request);
}
else if (InputStream.class.isAssignableFrom(parameterType)) {
return request.getInputStream();
}
else if (Reader.class.isAssignableFrom(parameterType)) {
return request.getReader();
}
else if (OutputStream.class.isAssignableFrom(parameterType)) {
return response.getOutputStream();
}
else if (Writer.class.isAssignableFrom(parameterType)) {
return response.getWriter();
}
else {
return WebArgumentResolver.UNRESOLVED;
}
}