下面列出了javax.servlet.http.PushBuilder#org.springframework.web.context.request.WebRequest 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
/**
* Register web-specific scopes ("request", "session", "globalSession", "application")
* with the given BeanFactory, as used by the WebApplicationContext.
* @param beanFactory the BeanFactory to configure
* @param sc the ServletContext that we're running within
*/
public static void registerWebApplicationScopes(ConfigurableListableBeanFactory beanFactory,
@Nullable ServletContext sc) {
beanFactory.registerScope(WebApplicationContext.SCOPE_REQUEST, new RequestScope());
beanFactory.registerScope(WebApplicationContext.SCOPE_SESSION, new SessionScope());
if (sc != null) {
ServletContextScope appScope = new ServletContextScope(sc);
beanFactory.registerScope(WebApplicationContext.SCOPE_APPLICATION, appScope);
// Register as ServletContext attribute, for ContextCleanupListener to detect it.
sc.setAttribute(ServletContextScope.class.getName(), appScope);
}
beanFactory.registerResolvableDependency(ServletRequest.class, new RequestObjectFactory());
beanFactory.registerResolvableDependency(ServletResponse.class, new ResponseObjectFactory());
beanFactory.registerResolvableDependency(HttpSession.class, new SessionObjectFactory());
beanFactory.registerResolvableDependency(WebRequest.class, new WebRequestObjectFactory());
if (jsfPresent) {
FacesDependencyRegistrar.registerFacesDependencies(beanFactory);
}
}
@PostMapping
public String uploadFacultyFile(RedirectAttributes attributes, @RequestParam MultipartFile file, HttpSession session, WebRequest webRequest) throws IOException {
try {
UploadResult<FacultyUpload> result = facultyUploadService.handleUpload(file);
if (!result.getErrors().isEmpty()) {
webRequest.removeAttribute(KEY_FACULTY_REGISTRATION, RequestAttributes.SCOPE_SESSION);
attributes.addFlashAttribute("faculty_errors", result.getErrors());
} else {
attributes.addFlashAttribute("faculty_success", true);
Confirmation<FacultyMember> confirmation = facultyUploadService.confirmUpload(result);
session.setAttribute(KEY_FACULTY_REGISTRATION, confirmation);
}
} catch (IOException ioe) {
log.error("Error registering faculty", ioe);
}
return "redirect:/admin/dean";
}
@Override
public void preHandle(WebRequest request) throws DataAccessException {
if (TransactionSynchronizationManager.hasResource(getPersistenceManagerFactory())) {
// Do not modify the PersistenceManager: just mark the request accordingly.
String participateAttributeName = getParticipateAttributeName();
Integer count = (Integer) request.getAttribute(participateAttributeName, WebRequest.SCOPE_REQUEST);
int newCount = (count != null ? count + 1 : 1);
request.setAttribute(getParticipateAttributeName(), newCount, WebRequest.SCOPE_REQUEST);
}
else {
logger.debug("Opening JDO PersistenceManager in OpenPersistenceManagerInViewInterceptor");
PersistenceManager pm =
PersistenceManagerFactoryUtils.getPersistenceManager(getPersistenceManagerFactory(), true);
TransactionSynchronizationManager.bindResource(
getPersistenceManagerFactory(), new PersistenceManagerHolder(pm));
}
}
/**
* Customize the response for AsyncRequestTimeoutException.
* <p>This method delegates to {@link #handleExceptionInternal}.
* @param ex the exception
* @param headers the headers to be written to the response
* @param status the selected response status
* @param webRequest the current request
* @return a {@code ResponseEntity} instance
* @since 4.2.8
*/
@Nullable
protected ResponseEntity<Object> handleAsyncRequestTimeoutException(
AsyncRequestTimeoutException ex, HttpHeaders headers, HttpStatus status, WebRequest webRequest) {
if (webRequest instanceof ServletWebRequest) {
ServletWebRequest servletWebRequest = (ServletWebRequest) webRequest;
HttpServletResponse response = servletWebRequest.getResponse();
if (response != null && response.isCommitted()) {
if (logger.isWarnEnabled()) {
logger.warn("Async request timed out");
}
return null;
}
}
return handleExceptionInternal(ex, null, headers, status, webRequest);
}
@Override
public void postHandle(WebRequest request, ModelMap model) throws DataAccessException {
SessionHolder sessionHolder = (SessionHolder)TransactionSynchronizationManager.getResource(getSessionFactory());
Session session = sessionHolder != null ? sessionHolder.getSession() : null;
try {
super.postHandle(request, model);
FlushMode flushMode = session != null ? session.getHibernateFlushMode() : null;
boolean isNotManual = flushMode != FlushMode.MANUAL && flushMode != FlushMode.COMMIT;
if (session != null && isNotManual) {
if(logger.isDebugEnabled()) {
logger.debug("Eagerly flushing Hibernate session");
}
session.flush();
}
}
finally {
if (session != null) {
session.setHibernateFlushMode(FlushMode.MANUAL);
}
}
}
/**
* RequestBody에서 request 값들을 객체화 실패했을때
*/
@Override
protected ResponseEntity<Object> handleHttpMessageNotReadable(
HttpMessageNotReadableException ex, HttpHeaders headers, HttpStatus status, WebRequest request) {
ServiceError serviceError = ServiceError.FORM_VALIDATION_FAILED;
RestErrorResponse restErrorResponse = new RestErrorResponse(serviceError);
try {
log.warn(ObjectMapperUtils.writeValueAsString(restErrorResponse), ex);
} catch (JsonProcessingException ignore) {
log.warn(ex.getLocalizedMessage(), ex);
}
return new ResponseEntity<>(restErrorResponse, HttpStatus.valueOf(serviceError.getHttpStatus()));
}
protected final void logException(final Exception ex,
final E errorResponse,
final WebRequest request) {
final StringBuilder sb = new StringBuilder();
sb.append(errorResponse);
sb.append("\n");
sb.append(request.getDescription(true));
sb.append("\nparameters -- ");
for (final Iterator<String> iter = request.getParameterNames(); iter.hasNext(); ) {
final String name = iter.next();
sb.append(name);
sb.append(":");
final String[] values = request.getParameterValues(name);
if (values == null) {
sb.append("null");
} else if (values.length == 0) {
sb.append("");
} else if (values.length == 1) {
sb.append(values[0]);
} else {
sb.append(Arrays.toString(values));
}
sb.append(" ");
}
logger.error(sb.toString(), ex);
}
@Override
protected ResponseEntity<Object> handleNoHandlerFoundException(NoHandlerFoundException ex,
HttpHeaders headers,
HttpStatus status,
WebRequest request)
{
ErrorDetail errorDetail = new ErrorDetail();
errorDetail.setTimestamp(new Date().getTime());
errorDetail.setStatus(HttpStatus.NOT_FOUND.value());
errorDetail.setTitle(ex.getRequestURL());
errorDetail.setDetail(request.getDescription(true));
errorDetail.setDeveloperMessage("Rest Handler Not Found (check for valid URI)");
return new ResponseEntity<>(errorDetail,
headers,
HttpStatus.NOT_FOUND);
}
@Override
protected ResponseEntity<Object> handleMissingPathVariable(MissingPathVariableException ex,
HttpHeaders headers,
HttpStatus status,
WebRequest request)
{
ErrorDetail errorDetail = new ErrorDetail();
errorDetail.setTimestamp(new Date().getTime());
errorDetail.setStatus(HttpStatus.BAD_REQUEST.value());
errorDetail.setTitle(ex.getVariableName() + " Missing Path Variable");
errorDetail.setDetail(ex.getMessage());
errorDetail.setDeveloperMessage(ex.getClass()
.getName());
return new ResponseEntity<>(errorDetail,
null,
HttpStatus.BAD_REQUEST);
}
@Test
public void testWithAccessTokenOnly() {
Application application = new Application();
application.evernotePropertiesConfiguration = new Application.EvernotePropertiesConfiguration();
WebRequest request = mock(WebRequest.class);
when(request.getHeader("evernote-rest-accesstoken")).thenReturn("ACCESS_TOKEN");
Evernote evernote = application.evernote(request);
assertThat(evernote, is(notNullValue()));
ClientFactory clientFactory = evernote.clientFactory();
assertThat(clientFactory, is(notNullValue()));
EvernoteAuth evernoteAuth = retrieveEvernoteAuth(clientFactory);
assertThat(evernoteAuth, is(notNullValue()));
assertThat(evernoteAuth.getToken(), is("ACCESS_TOKEN"));
assertThat(evernoteAuth.getNoteStoreUrl(), is(nullValue()));
assertThat(evernoteAuth.getUserId(), is(0)); // default
assertThat(evernoteAuth.getWebApiUrlPrefix(), is(nullValue()));
}
@Override
public boolean supportsParameter(MethodParameter parameter) {
Class<?> paramType = parameter.getParameterType();
return (WebRequest.class.isAssignableFrom(paramType) ||
ServletRequest.class.isAssignableFrom(paramType) ||
MultipartRequest.class.isAssignableFrom(paramType) ||
HttpSession.class.isAssignableFrom(paramType) ||
Principal.class.isAssignableFrom(paramType) ||
InputStream.class.isAssignableFrom(paramType) ||
Reader.class.isAssignableFrom(paramType) ||
HttpMethod.class == paramType ||
Locale.class == paramType ||
TimeZone.class == paramType ||
"java.time.ZoneId".equals(paramType.getName()));
}
/**
* Open a new Hibernate {@code Session} according and bind it to the thread via the
* {@link TransactionSynchronizationManager}.
*/
@Override
public void preHandle(WebRequest request) throws DataAccessException {
String key = getParticipateAttributeName();
WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
if (asyncManager.hasConcurrentResult() && applySessionBindingInterceptor(asyncManager, key)) {
return;
}
if (TransactionSynchronizationManager.hasResource(obtainSessionFactory())) {
// Do not modify the Session: just mark the request accordingly.
Integer count = (Integer) request.getAttribute(key, WebRequest.SCOPE_REQUEST);
int newCount = (count != null ? count + 1 : 1);
request.setAttribute(getParticipateAttributeName(), newCount, WebRequest.SCOPE_REQUEST);
}
else {
logger.debug("Opening Hibernate Session in OpenSessionInViewInterceptor");
Session session = openSession();
SessionHolder sessionHolder = new SessionHolder(session);
TransactionSynchronizationManager.bindResource(obtainSessionFactory(), sessionHolder);
AsyncRequestInterceptor asyncRequestInterceptor =
new AsyncRequestInterceptor(obtainSessionFactory(), sessionHolder);
asyncManager.registerCallableInterceptor(key, asyncRequestInterceptor);
asyncManager.registerDeferredResultInterceptor(key, asyncRequestInterceptor);
}
}
/**
* {@inheritDoc}
*
* Handle HttpMediaTypeNotSupportedException. This one triggers when JSON is invalid
* as well.
*/
@Override
protected ResponseEntity<Object> handleHttpMediaTypeNotSupported(HttpMediaTypeNotSupportedException ex,
HttpHeaders headers, HttpStatus status, WebRequest request) {
final StringBuilder builder = new StringBuilder();
builder.append(ex.getContentType());
builder.append(" media type is not supported. Supported media types are ");
ex.getSupportedMediaTypes().forEach(mediaType -> builder.append(mediaType).append(", "));
return buildResponseEntity(
new ApiError(HttpStatus.UNSUPPORTED_MEDIA_TYPE, builder.substring(0, builder.length() - 2), ex));
}
/**
* Handle MethodArgumentNotValidException. Triggered when an object fails @Valid validation.
*
* @param ex the MethodArgumentNotValidException that is thrown when @Valid validation fails
* @param headers HttpHeaders
* @param status HttpStatus
* @param request WebRequest
* @return the ApiError object
*/
@Override
protected ResponseEntity<Object> handleMethodArgumentNotValid(
MethodArgumentNotValidException ex,
HttpHeaders headers,
HttpStatus status,
WebRequest request) {
ApiError apiError = new ApiError(BAD_REQUEST);
apiError.setMessage("Validation error");
apiError.addValidationErrors(ex.getBindingResult().getFieldErrors());
apiError.addValidationError(ex.getBindingResult().getGlobalErrors());
return buildResponseEntity(apiError);
}
private boolean decrementParticipateCount(WebRequest request) {
String participateAttributeName = getParticipateAttributeName();
Integer count = (Integer) request.getAttribute(participateAttributeName, WebRequest.SCOPE_REQUEST);
if (count == null) {
return false;
}
// Do not modify the Session: just clear the marker.
if (count > 1) {
request.setAttribute(participateAttributeName, count - 1, WebRequest.SCOPE_REQUEST);
}
else {
request.removeAttribute(participateAttributeName, WebRequest.SCOPE_REQUEST);
}
return true;
}
/**
*
* @param webRequest initial request
* @param errorCode
* @return error attributes to return to client
*/
public Map<String, Object> getErrorAttributes(WebRequest webRequest, UserInterfaceErrorCodes errorCode) {
Map<String, Object> errorAttributes = super.getErrorAttributes(webRequest, false);
errorAttributes.put("message", errorCode.getErrorMessage());
errorAttributes.put("status", errorCode.getHttpErrorCode());
errorAttributes.put("userAction", errorCode.getUserAction());
errorAttributes.put("systemAction", errorCode.getSystemAction());
errorAttributes.put("errorId", errorCode.getErrorMessageId());
return errorAttributes;
}
@Test
public void controllerAdvice_HttpErrorShouldContainAppropriateDetails() throws Exception {
ArgumentCaptor<HttpError> captor = ArgumentCaptor.forClass(HttpError.class);
mvc.perform(get("/test//type-mismatch").param("number", "not a number"))
.andExpect(status().isBadRequest());
verify(processor).process(captor.capture());
HttpError value = captor.getValue();
assertThat(value.getRequest()).isNotNull();
assertThat(value.getRequest()).isInstanceOf(WebRequest.class);
assertThat(value.getOriginalException()).isNotNull();
assertThat(value.getRefinedException()).isNotNull();
}
private boolean decrementParticipateCount(WebRequest request) {
String participateAttributeName = getParticipateAttributeName();
Integer count = (Integer) request.getAttribute(participateAttributeName, WebRequest.SCOPE_REQUEST);
if (count == null) {
return false;
}
// Do not modify the Session: just clear the marker.
if (count > 1) {
request.setAttribute(participateAttributeName, count - 1, WebRequest.SCOPE_REQUEST);
}
else {
request.removeAttribute(participateAttributeName, WebRequest.SCOPE_REQUEST);
}
return true;
}
@Override
public void afterCompletion(WebRequest request, Exception ex) throws DataAccessException {
if (!decrementParticipateCount(request)) {
EntityManagerHolder emHolder = (EntityManagerHolder)
TransactionSynchronizationManager.unbindResource(getEntityManagerFactory());
logger.debug("Closing JPA EntityManager in OpenEntityManagerInViewInterceptor");
EntityManagerFactoryUtils.closeEntityManager(emHolder.getEntityManager());
}
}
@ExceptionHandler(value = {Exception.class, RuntimeException.class})
//@ResponseBody
public ResponseEntity<ResponseMessage> handleGenericException(Exception ex, WebRequest request) {
if (log.isDebugEnabled()) {
log.debug("handling exception...");
}
return new ResponseEntity<>(new ResponseMessage(ResponseMessage.Type.danger, ex.getMessage()), HttpStatus.BAD_REQUEST);
}
/**
*
* @param ex - raised exception to be handled
* @param request - the initial web request
* @return the entity containing the response exception
*/
@ExceptionHandler(value = {InvalidParameterException.class, PropertyServerException.class})
protected ResponseEntity<Object> handleAssetCatalogException(AssetCatalogException ex, WebRequest request) {
LOG.error(ex.getMessage(), ex);
Map<String, Object> errorAttributes = this.errorAttributes.getErrorAttributes(request, UserInterfaceErrorCodes.INVALID_REQUEST_FOR_ASSET_CATALOG);
return handleExceptionInternal(ex, errorAttributes,
new HttpHeaders(), UserInterfaceErrorCodes.INVALID_REQUEST_FOR_ASSET_CATALOG.getHttpErrorCode(), request);
}
/**
* Customize the response for HttpRequestMethodNotSupportedException.
* <p>This method logs a warning, sets the "Allow" header, and delegates to
* {@link #handleExceptionInternal}.
* @param ex the exception
* @param headers the headers to be written to the response
* @param status the selected response status
* @param request the current request
* @return a {@code ResponseEntity} instance
*/
protected ResponseEntity<Object> handleHttpRequestMethodNotSupported(HttpRequestMethodNotSupportedException ex,
HttpHeaders headers, HttpStatus status, WebRequest request) {
pageNotFoundLogger.warn(ex.getMessage());
Set<HttpMethod> supportedMethods = ex.getSupportedHttpMethods();
if (!CollectionUtils.isEmpty(supportedMethods)) {
headers.setAllow(supportedMethods);
}
return handleExceptionInternal(ex, null, headers, status, request);
}
@ExceptionHandler(MissingBearerTokenException.class)
@ResponseBody
public ResponseEntity<V1ErrorResponse> handleMissingBearerTokenException(final MissingBearerTokenException ex,
final WebRequest request) {
final HttpStatus status = HttpStatus.UNAUTHORIZED;
final V1ErrorResponse errorResponse = createErrorResponse(status,
"missing Bearer token in Authorization header");
HttpHeaders responseHeaders = new HttpHeaders();
responseHeaders.add(Oauths.HeaderType.WWW_AUTHENTICATE, realm());
return new ResponseEntity<>(errorResponse, responseHeaders, status);
}
/**
* Open a new Hibernate {@code Session} according and bind it to the thread via the
* {@link TransactionSynchronizationManager}.
*/
@Override
public void preHandle(WebRequest request) throws DataAccessException {
String participateAttributeName = getParticipateAttributeName();
WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
if (asyncManager.hasConcurrentResult()) {
if (applySessionBindingInterceptor(asyncManager, participateAttributeName)) {
return;
}
}
if (TransactionSynchronizationManager.hasResource(getSessionFactory())) {
// Do not modify the Session: just mark the request accordingly.
Integer count = (Integer) request.getAttribute(participateAttributeName, WebRequest.SCOPE_REQUEST);
int newCount = (count != null ? count + 1 : 1);
request.setAttribute(getParticipateAttributeName(), newCount, WebRequest.SCOPE_REQUEST);
}
else {
logger.debug("Opening Hibernate Session in OpenSessionInViewInterceptor");
Session session = openSession();
SessionHolder sessionHolder = new SessionHolder(session);
TransactionSynchronizationManager.bindResource(getSessionFactory(), sessionHolder);
AsyncRequestInterceptor asyncRequestInterceptor =
new AsyncRequestInterceptor(getSessionFactory(), sessionHolder);
asyncManager.registerCallableInterceptor(participateAttributeName, asyncRequestInterceptor);
asyncManager.registerDeferredResultInterceptor(participateAttributeName, asyncRequestInterceptor);
}
}
@ExceptionHandler({AccessDeniedException.class})
protected ResponseEntity<Object> handleAccessDeniedException(Exception e, WebRequest request) {
if (log.isDebugEnabled())
log.error("Exception was thrown -> Retrun message: " + e.getMessage(), e);
else log.error("Exception was thrown -> Retrun message: " + e.getMessage());
ExceptionResource exceptionResource = new ExceptionResource("Access denied", e.getMessage());
return handleExceptionInternal(
e, exceptionResource, new HttpHeaders(), HttpStatus.FORBIDDEN, request);
}
@Override
public void storeAttribute(WebRequest request, String attributeName, Object attributeValue) {
Assert.notNull(request, "WebRequest must not be null");
Assert.notNull(attributeName, "Attribute name must not be null");
Assert.notNull(attributeValue, "Attribute value must not be null");
String storeAttributeName = getAttributeNameInSession(request, attributeName);
request.setAttribute(storeAttributeName, attributeValue, WebRequest.SCOPE_SESSION);
}
@ExceptionHandler({ QueryTimeoutException.class })
@ResponseBody
public ResponseEntity<E> handleQueryTimeoutException(final QueryTimeoutException ex,
final WebRequest request) {
final HttpStatus status = HttpStatus.REQUEST_TIMEOUT;
final E errorResponse = createErrorResponse(status,
i18n(request, "rest-error.QueryTimeoutException"));
logException(ex, errorResponse, request);
return new ResponseEntity<>(errorResponse, status);
}
@ExceptionHandler({ Exception.class })
public ResponseEntity<Object> handleAll(final Exception ex, final WebRequest request) {
logger.info(ex.getClass().getName());
logger.error("error", ex);
//
final ApiError apiError = new ApiError(HttpStatus.INTERNAL_SERVER_ERROR, ex.getLocalizedMessage(), "error occurred");
return new ResponseEntity<Object>(apiError, new HttpHeaders(), apiError.getStatus());
}
/**
* Handle DataIntegrityViolationException, inspects the cause for different DB causes.
*
* @param ex the DataIntegrityViolationException
* @return the ApiError object
*/
@ExceptionHandler(DataIntegrityViolationException.class)
protected ResponseEntity<Object> handleDataIntegrityViolation(DataIntegrityViolationException ex,
WebRequest request) {
if (ex.getCause() instanceof ConstraintViolationException) {
return buildResponseEntity(new ApiError(HttpStatus.CONFLICT, "Database error", ex.getCause()));
}
return buildResponseEntity(new ApiError(HttpStatus.INTERNAL_SERVER_ERROR, ex));
}
/**
* {@inheritDoc}
*
* Handle HttpMessageNotWritableException.
*/
@Override
protected ResponseEntity<Object> handleHttpMessageNotWritable(HttpMessageNotWritableException ex,
HttpHeaders headers, HttpStatus status, WebRequest request) {
final String error = "Error writing JSON output";
return buildResponseEntity(new ApiError(HttpStatus.INTERNAL_SERVER_ERROR, error, ex));
}