Java RequestMethod.HEAD属性代码示例

/**
 * Mapping to several HTTP request methods is not OK if it's a mix of unprotected and protected HTTP request methods.
 */
@RequestMapping(value = "/request-mapping-all-unprotected-methods-and-one-protected-method",
        method = {RequestMethod.GET, RequestMethod.HEAD, RequestMethod.TRACE, RequestMethod.OPTIONS, RequestMethod.PATCH})
public void requestMappingAllUnprotectedMethodsAndOneProtectedMethod() {
}
 

/**
 * Operation to determine if a bucket exists.
 *
 * @param bucketName name of the Bucket to be checked.
 * @return ResponseEntity Code 200 OK; 404 Not found.
 */
@RequestMapping(value = "/{bucketName}", method = RequestMethod.HEAD)
public ResponseEntity<String> headBucket(@PathVariable final String bucketName) {
  if (fileStore.doesBucketExist(bucketName)) {
    return new ResponseEntity<>(HttpStatus.OK);
  } else {
    return new ResponseEntity<>(HttpStatus.NOT_FOUND);
  }
}
 

/**
 * Retrieves metadata from an object without returning the object itself.
 *
 * @param bucketName name of the bucket to look in
 * @return ResponseEntity containing metadata and status
 */
@RequestMapping(
    value = "/{bucketName:.+}/**",
    method = RequestMethod.HEAD)
public ResponseEntity<String> headObject(@PathVariable final String bucketName,
    final HttpServletRequest request) {
  final String filename = filenameFrom(bucketName, request);

  final S3Object s3Object = fileStore.getS3Object(bucketName, filename);
  if (s3Object != null) {
    final HttpHeaders responseHeaders = new HttpHeaders();
    responseHeaders.setContentLength(Long.valueOf(s3Object.getSize()));
    if (!"".equals(s3Object.getContentType())) {
      responseHeaders.setContentType(MediaType.parseMediaType(s3Object.getContentType()));
    }
    responseHeaders.setETag("\"" + s3Object.getMd5() + "\"");
    responseHeaders.setLastModified(s3Object.getLastModified());

    if (s3Object.isEncrypted()) {
      responseHeaders.add(SERVER_SIDE_ENCRYPTION_AWS_KMS_KEYID,
          s3Object.getKmsKeyId());
    }

    return new ResponseEntity<>(responseHeaders, HttpStatus.OK);
  } else {
    return new ResponseEntity<>(HttpStatus.NOT_FOUND);
  }
}
 

@ApiOperation(value = "", notes = "Retrieve Jenkins headers", response = Void.class, authorizations = {
    @Authorization(value = "jenkins_auth")
}, tags={ "remoteAccess", })
@ApiResponses(value = { 
    @ApiResponse(code = 200, message = "Successfully retrieved Jenkins headers", response = Void.class),
    @ApiResponse(code = 401, message = "Authentication failed - incorrect username and/or password", response = Void.class),
    @ApiResponse(code = 403, message = "Jenkins requires authentication - please set username and password", response = Void.class) })
@RequestMapping(value = "/api/json",
    method = RequestMethod.HEAD)
ResponseEntity<Void> headJenkins( @RequestHeader(value = "Accept", required = false) String accept) throws Exception;
 

@RequestMapping(value = "/head", method = RequestMethod.HEAD)
@ResponseBody
public Map<String, String> head() {
  Map<String, String> source = new HashMap<>();
  source.put("now", Calendar.getInstance().getTime().toString());
  log.info("head......");
  return source;
}
 

/**
 * Blog articles Atom output.
 *
 * @param context
 *            the specified context
 */
@RequestMapping(value = { "/blog-articles-feed.do" }, method = { RequestMethod.GET, RequestMethod.HEAD })
public void blogArticlesAtom(final HttpServletRequest request, final HttpServletResponse response) {
	final AtomRenderer renderer = new AtomRenderer();
	final Feed feed = new Feed();

	try {
		final JSONObject preference = preferenceQueryService.getPreference();

		final String blogTitle = preference.getString(Option.ID_C_BLOG_TITLE);
		final String blogSubtitle = preference.getString(Option.ID_C_BLOG_SUBTITLE);
		final int outputCnt = preference.getInt(Option.ID_C_FEED_OUTPUT_CNT);

		feed.setTitle(StringEscapeUtils.escapeXml(blogTitle));
		feed.setSubtitle(StringEscapeUtils.escapeXml(blogSubtitle));
		feed.setUpdated(new Date());
		feed.setAuthor(StringEscapeUtils.escapeXml(blogTitle));
		feed.setLink(Latkes.getServePath() + "/blog-articles-feed.do");
		feed.setId(Latkes.getServePath() + "/");

		final List<Filter> filters = new ArrayList<>();

		filters.add(new PropertyFilter(Article.ARTICLE_IS_PUBLISHED, FilterOperator.EQUAL, true));
		filters.add(new PropertyFilter(Article.ARTICLE_VIEW_PWD, FilterOperator.EQUAL, ""));
		final Query query = new Query().setCurrentPageNum(1).setPageSize(outputCnt)
				.setFilter(new CompositeFilter(CompositeFilterOperator.AND, filters))
				.addSort(Article.ARTICLE_UPDATE_DATE, SortDirection.DESCENDING).setPageCount(1);

		final boolean hasMultipleUsers = userQueryService.hasMultipleUsers();
		String authorName = "";

		final JSONObject articleResult = articleDao.get(query);
		final JSONArray articles = articleResult.getJSONArray(Keys.RESULTS);

		if (!hasMultipleUsers && 0 != articles.length()) {
			authorName = articleQueryService.getAuthor(articles.getJSONObject(0)).getString(User.USER_NAME);
		}

		final boolean isFullContent = "fullContent".equals(preference.getString(Option.ID_C_FEED_OUTPUT_MODE));

		for (int i = 0; i < articles.length(); i++) {
			Entry entry = getEntry(hasMultipleUsers, authorName, articles, isFullContent, i);
			feed.addEntry(entry);
		}

		renderer.setContent(feed.toString());
	} catch (final Exception e) {
		logger.error("Get blog article feed error", e);

		try {
			response.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE);
		} catch (final IOException ex) {
			throw new RuntimeException(ex);
		}
	}
	renderer.render(request, response);
}
 

/**
 * Blog articles RSS output.
 *
 * @param context
 *            the specified context
 */
@RequestMapping(value = { "/blog-articles-rss.do" }, method = { RequestMethod.GET, RequestMethod.HEAD })
public void blogArticlesRSS(final HttpServletRequest request, final HttpServletResponse response) {
	final RssRenderer renderer = new RssRenderer();
	final Channel channel = new Channel();

	try {
		final JSONObject preference = preferenceQueryService.getPreference();

		if (null == preference) {
			response.sendError(HttpServletResponse.SC_NOT_FOUND);
			return;
		}

		final String blogTitle = preference.getString(Option.ID_C_BLOG_TITLE);
		final String blogSubtitle = preference.getString(Option.ID_C_BLOG_SUBTITLE);
		final int outputCnt = preference.getInt(Option.ID_C_FEED_OUTPUT_CNT);

		channel.setTitle(StringEscapeUtils.escapeXml(blogTitle));
		channel.setLastBuildDate(new Date());
		channel.setLink(Latkes.getServePath());
		channel.setAtomLink(Latkes.getServePath() + "/blog-articles-rss.do");
		channel.setGenerator("Solo, ver " + SoloConstant.VERSION);
		final String localeString = preference.getString(Option.ID_C_LOCALE_STRING);
		final String country = Locales.getCountry(localeString).toLowerCase();
		final String language = Locales.getLanguage(localeString).toLowerCase();

		channel.setLanguage(language + '-' + country);
		channel.setDescription(blogSubtitle);

		final List<Filter> filters = new ArrayList<>();

		filters.add(new PropertyFilter(Article.ARTICLE_IS_PUBLISHED, FilterOperator.EQUAL, true));
		filters.add(new PropertyFilter(Article.ARTICLE_VIEW_PWD, FilterOperator.EQUAL, ""));
		final Query query = new Query().setCurrentPageNum(1).setPageSize(outputCnt)
				.setFilter(new CompositeFilter(CompositeFilterOperator.AND, filters))
				.addSort(Article.ARTICLE_UPDATE_DATE, SortDirection.DESCENDING).setPageCount(1);

		final JSONObject articleResult = articleDao.get(query);
		final JSONArray articles = articleResult.getJSONArray(Keys.RESULTS);

		final boolean hasMultipleUsers = userQueryService.hasMultipleUsers();
		String authorName = "";

		if (!hasMultipleUsers && 0 != articles.length()) {
			authorName = articleQueryService.getAuthor(articles.getJSONObject(0)).getString(User.USER_NAME);
		}

		final boolean isFullContent = "fullContent".equals(preference.getString(Option.ID_C_FEED_OUTPUT_MODE));

		for (int i = 0; i < articles.length(); i++) {
			Item item = getItem(articles, hasMultipleUsers, authorName, isFullContent, i);
			channel.addItem(item);
		}

		renderer.setContent(channel.toString());
	} catch (final Exception e) {
		logger.error("Get blog article rss error", e);

		try {
			response.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE);
		} catch (final IOException ex) {
			throw new RuntimeException(ex);
		}
	}
	renderer.render(request, response);
}
 

@RequestMapping(method = {RequestMethod.GET, RequestMethod.HEAD}, value = "/ping")
public ResponseEntity<String> ping() {
  return new ResponseEntity<String>("<html><body><h1>Mischief Managed!</h1></body></html>",
      HttpStatus.OK);
}
 

@RequestMapping(value = "/pingpong.html", method = RequestMethod.HEAD)
@ResponseBody
public String getServerStatus() {
	return SyncConstants.SUCCESS;
}
 

/**
 * Mapping to the HTTP request method `HEAD` is safe as long as no state-changing operations are performed within this method.
 */
@RequestMapping(value = "/request-mapping-head", method = RequestMethod.HEAD)
public void requestMappingHead() {
}
 

/**
 * Mapping to several HTTP request methods is fine as long as all the HTTP request methods used are unprotected.
 */
@RequestMapping(value = "/request-mapping-several-unprotected-methods",
        method = {RequestMethod.GET, RequestMethod.HEAD, RequestMethod.TRACE, RequestMethod.OPTIONS})
public void requestMappingSeveralUnprotectedMethods() {
}