String getContent(HttpMethod httpMethod) { StringBuilder contentBuilder = new StringBuilder(); if (isZipContent(httpMethod)) { InputStream is = null; GZIPInputStream gzin = null; InputStreamReader isr = null; BufferedReader br = null; try { is = httpMethod.getResponseBodyAsStream(); gzin = new GZIPInputStream(is); isr = new InputStreamReader( gzin, ((HttpMethodBase) httpMethod).getResponseCharSet()); // ���ö�ȡ���ı����ʽ���Զ������ br = new BufferedReader(isr); char[] buffer = new char[4096]; int readlen = -1; while ((readlen = br.read(buffer, 0, 4096)) != -1) { contentBuilder.append(buffer, 0, readlen); } } catch (Exception e) { log.error("Unzip fail", e); } finally { try { br.close(); } catch (Exception e1) { // ignore } try { isr.close(); } catch (Exception e1) { // ignore } try { gzin.close(); } catch (Exception e1) { // ignore } try { is.close(); } catch (Exception e1) { // ignore } } } else { String content = null; try { content = httpMethod.getResponseBodyAsString(); } catch (Exception e) { log.error("Fetch config error:", e); } if (null == content) { return null; } contentBuilder.append(content); } return contentBuilder.toString(); }
boolean isZipContent(HttpMethod httpMethod) { if (null != httpMethod.getResponseHeader(Constants.CONTENT_ENCODING)) { String acceptEncoding = httpMethod.getResponseHeader(Constants.CONTENT_ENCODING).getValue(); if (acceptEncoding.toLowerCase().indexOf("gzip") > -1) { return true; } } return false; }
private String getNotModified(String dataId, CacheData cacheData, HttpMethod httpMethod) { Header md5Header = httpMethod.getResponseHeader(Constants.CONTENT_MD5); if (null == md5Header) { throw new RuntimeException("RP_NO_CHANGE response not contain MD5"); } String md5 = md5Header.getValue(); if (!cacheData.getMd5().equals(md5)) { String lastMd5 = cacheData.getMd5(); cacheData.setMd5(Constants.NULL); cacheData.setLastModifiedHeader(Constants.NULL); throw new RuntimeException( "MD5 verify error,DataID:[" + dataId + "]MD5 last:[" + lastMd5 + "]MD5 current:[" + md5 + "]"); } cacheData.setMd5(md5); changeSpacingInterval(httpMethod); if (log.isInfoEnabled()) { log.info("DataId: " + dataId + ",not changed"); } return null; }
/** * Handles requests with message handler implementation. Previously sets Http request method as * header parameter. * * @param method * @param requestEntity * @return */ private ResponseEntity<String> handleRequestInternal( HttpMethod method, HttpEntity<String> requestEntity) { Map<String, ?> httpRequestHeaders = headerMapper.toHeaders(requestEntity.getHeaders()); Map<String, String> customHeaders = new HashMap<String, String>(); for (Entry<String, List<String>> header : requestEntity.getHeaders().entrySet()) { if (!httpRequestHeaders.containsKey(header.getKey())) { customHeaders.put( header.getKey(), StringUtils.collectionToCommaDelimitedString(header.getValue())); } } HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest(); UrlPathHelper pathHelper = new UrlPathHelper(); customHeaders.put(CitrusHttpMessageHeaders.HTTP_REQUEST_URI, pathHelper.getRequestUri(request)); customHeaders.put( CitrusHttpMessageHeaders.HTTP_CONTEXT_PATH, pathHelper.getContextPath(request)); String queryParams = pathHelper.getOriginatingQueryString(request); customHeaders.put( CitrusHttpMessageHeaders.HTTP_QUERY_PARAMS, queryParams != null ? queryParams : ""); customHeaders.put(CitrusHttpMessageHeaders.HTTP_REQUEST_METHOD, method.toString()); Message<?> response = messageHandler.handleMessage( MessageBuilder.withPayload(requestEntity.getBody()) .copyHeaders(convertHeaderTypes(httpRequestHeaders)) .copyHeaders(customHeaders) .build()); return generateResponse(response); }
private String getSuccess( String dataId, String group, CacheData cacheData, HttpMethod httpMethod) { String configInfo = Constants.NULL; configInfo = getContent(httpMethod); if (null == configInfo) { throw new RuntimeException("RP_OK configInfo is null"); } Header md5Header = httpMethod.getResponseHeader(Constants.CONTENT_MD5); if (null == md5Header) { throw new RuntimeException("RP_OK not contain MD5, " + configInfo); } String md5 = md5Header.getValue(); if (!checkContent(configInfo, md5)) { throw new RuntimeException( "MD5 verify error,DataID:[" + dataId + "]ConfigInfo:[" + configInfo + "]MD5:[" + md5 + "]"); } Header lastModifiedHeader = httpMethod.getResponseHeader(Constants.LAST_MODIFIED); if (null == lastModifiedHeader) { throw new RuntimeException("RP_OK result not contain lastModifiedHeader"); } String lastModified = lastModifiedHeader.getValue(); cacheData.setMd5(md5); cacheData.setLastModifiedHeader(lastModified); changeSpacingInterval(httpMethod); String key = makeCacheKey(dataId, group); contentCache.put(key, configInfo); StringBuilder buf = new StringBuilder(); buf.append("dataId=").append(dataId); buf.append(" ,group=").append(group); buf.append(" ,content=").append(configInfo); dataLog.info(buf.toString()); return configInfo; }
/* * (non-Javadoc) * @see org.jasig.portlet.weather.dao.IWeatherDao#find(java.lang.String) */ public Collection<Location> find(String location) { final String url = FIND_URL .replace("@KEY@", key) .replace("@QUERY@", QuietUrlCodec.encode(location, Constants.URL_ENCODING)); HttpMethod getMethod = new GetMethod(url); InputStream inputStream = null; try { // Execute the method. int statusCode = httpClient.executeMethod(getMethod); if (statusCode != HttpStatus.SC_OK) { final String statusText = getMethod.getStatusText(); throw new DataRetrievalFailureException( "get of '" + url + "' failed with status '" + statusCode + "' due to '" + statusText + "'"); } // Read the response body inputStream = getMethod.getResponseBodyAsStream(); List<Location> locations = deserializeSearchResults(inputStream); return locations; } catch (HttpException e) { throw new RuntimeException( "http protocol exception while getting data from weather service from: " + url, e); } catch (IOException e) { throw new RuntimeException( "IO exception while getting data from weather service from: " + url, e); } catch (JAXBException e) { throw new RuntimeException( "Parsing exception while getting data from weather service from: " + url, e); } finally { // try to close the inputstream IOUtils.closeQuietly(inputStream); // release the connection getMethod.releaseConnection(); } }
protected HttpContext read(HttpServletRequest request) throws IOException { String url = request.getPathInfo(); HttpMethod httpMethod = HttpMethod.valueOf(request.getMethod()); HttpHeaders headers = this.headers(request); String content = this.content(request); return new HttpContext(url, httpMethod, headers, content); }
protected Object getAndDeserialize(String url, TemperatureUnit unit) { HttpMethod getMethod = new GetMethod(url); InputStream inputStream = null; try { // Execute the method. int statusCode = httpClient.executeMethod(getMethod); if (statusCode != HttpStatus.SC_OK) { final String statusText = getMethod.getStatusText(); throw new DataRetrievalFailureException( "get of '" + url + "' failed with status '" + statusCode + "' due to '" + statusText + "'"); } // Read the response body inputStream = getMethod.getResponseBodyAsStream(); Weather weather = deserializeWeatherResult(inputStream, unit); return weather; } catch (HttpException e) { throw new RuntimeException( "http protocol exception while getting data from weather service from: " + url, e); } catch (IOException e) { throw new RuntimeException( "IO exception while getting data from weather service from: " + url, e); } catch (JAXBException e) { throw new RuntimeException( "Parsing exception while getting data from weather service from: " + url, e); } catch (ParseException e) { throw new RuntimeException( "Parsing exception while getting data from weather service from: " + url, e); } finally { // try to close the inputstream IOUtils.closeQuietly(inputStream); // release the connection getMethod.releaseConnection(); } }
Set<String> getUpdateDataIdsInBody(HttpMethod httpMethod) { Set<String> modifiedDataIdSet = new HashSet<String>(); try { String modifiedDataIdsString = httpMethod.getResponseBodyAsString(); return convertStringToSet(modifiedDataIdsString); } catch (Exception e) { } return modifiedDataIdSet; }
void changeSpacingInterval(HttpMethod httpMethod) { Header[] spacingIntervalHeaders = httpMethod.getResponseHeaders(Constants.SPACING_INTERVAL); if (spacingIntervalHeaders.length >= 1) { try { diamondConfigure.setPollingIntervalTime( Integer.parseInt(spacingIntervalHeaders[0].getValue())); } catch (RuntimeException e) { log.error("�����´μ��ʱ��ʧ��", e); } } }
private void configureHttpMethod( boolean skipContentCache, CacheData cacheData, long onceTimeOut, HttpMethod httpMethod) { if (skipContentCache && null != cacheData) { if (null != cacheData.getLastModifiedHeader() && Constants.NULL != cacheData.getLastModifiedHeader()) { httpMethod.addRequestHeader(Constants.IF_MODIFIED_SINCE, cacheData.getLastModifiedHeader()); } if (null != cacheData.getMd5() && Constants.NULL != cacheData.getMd5()) { httpMethod.addRequestHeader(Constants.CONTENT_MD5, cacheData.getMd5()); } } httpMethod.addRequestHeader(Constants.ACCEPT_ENCODING, "gzip,deflate"); HttpMethodParams params = new HttpMethodParams(); params.setSoTimeout((int) onceTimeOut); httpMethod.setParams(params); httpClient .getHostConfiguration() .setHost( diamondConfigure.getDomainNameList().get(this.domainNamePos.get()), diamondConfigure.getPort()); }
/** * @see com.consol.citrus.message.MessageSender#send(org.springframework.integration.Message) * @throws CitrusRuntimeException */ public void send(Message<?> message) { String endpointUri; if (endpointUriResolver != null) { endpointUri = endpointUriResolver.resolveEndpointUri(message, getRequestUrl()); } else { endpointUri = getRequestUrl(); } log.info("Sending HTTP message to: '" + endpointUri + "'"); if (log.isDebugEnabled()) { log.debug("Message to be sent:\n" + message.getPayload().toString()); } HttpMethod method = requestMethod; if (message.getHeaders().containsKey(CitrusHttpMessageHeaders.HTTP_REQUEST_METHOD)) { method = HttpMethod.valueOf( (String) message.getHeaders().get(CitrusHttpMessageHeaders.HTTP_REQUEST_METHOD)); } HttpEntity<?> requestEntity = generateRequest(message, method); restTemplate.setErrorHandler(new InternalResponseErrorHandler(message)); ResponseEntity<?> response = restTemplate.exchange(endpointUri, method, requestEntity, String.class); log.info("HTTP message was successfully sent to endpoint: '" + endpointUri + "'"); informReplyMessageHandler( buildResponseMessage( response.getHeaders(), response.getBody() != null ? response.getBody() : "", response.getStatusCode()), message); }
/** * Makes a rest request of any type at the specified urlSuffix. The urlSuffix should be of the * form /userService/users. If CS throws an exception it handled and transalated to a Openfire * exception if possible. This is done using the check fault method that tries to throw the best * maching exception. * * @param type Must be GET or DELETE * @param urlSuffix The url suffix of the rest request * @param xmlParams The xml with the request params, must be null if type is GET or DELETE only * @return The response as a xml doc. * @throws ConnectionException Thrown if there are issues perfoming the request. * @throws Exception Thrown if the response from Clearspace contains an exception. */ public Element executeRequest(HttpType type, String urlSuffix, String xmlParams) throws ConnectionException, Exception { if (Log.isDebugEnabled()) { Log.debug("Outgoing REST call [" + type + "] to " + urlSuffix + ": " + xmlParams); } String wsUrl = getConnectionURI() + WEBSERVICES_PATH + urlSuffix; String secret = getSharedSecret(); HttpClient client = new HttpClient(); HttpMethod method; // Configures the authentication client.getParams().setAuthenticationPreemptive(true); Credentials credentials = new UsernamePasswordCredentials(OPENFIRE_USERNAME, secret); AuthScope scope = new AuthScope(host, port, AuthScope.ANY_REALM); client.getState().setCredentials(scope, credentials); // Creates the method switch (type) { case GET: method = new GetMethod(wsUrl); break; case POST: PostMethod pm = new PostMethod(wsUrl); StringRequestEntity requestEntity = new StringRequestEntity(xmlParams); pm.setRequestEntity(requestEntity); method = pm; break; case PUT: PutMethod pm1 = new PutMethod(wsUrl); StringRequestEntity requestEntity1 = new StringRequestEntity(xmlParams); pm1.setRequestEntity(requestEntity1); method = pm1; break; case DELETE: method = new DeleteMethod(wsUrl); break; default: throw new IllegalArgumentException(); } method.setRequestHeader("Accept", "text/xml"); method.setDoAuthentication(true); try { // Executes the request client.executeMethod(method); // Parses the result String body = method.getResponseBodyAsString(); if (Log.isDebugEnabled()) { Log.debug("Outgoing REST call results: " + body); } // Checks the http status if (method.getStatusCode() != 200) { if (method.getStatusCode() == 401) { throw new ConnectionException( "Invalid password to connect to Clearspace.", ConnectionException.ErrorType.AUTHENTICATION); } else if (method.getStatusCode() == 404) { throw new ConnectionException( "Web service not found in Clearspace.", ConnectionException.ErrorType.PAGE_NOT_FOUND); } else if (method.getStatusCode() == 503) { throw new ConnectionException( "Web service not avaible in Clearspace.", ConnectionException.ErrorType.SERVICE_NOT_AVAIBLE); } else { throw new ConnectionException( "Error connecting to Clearspace, http status code: " + method.getStatusCode(), new HTTPConnectionException(method.getStatusCode()), ConnectionException.ErrorType.OTHER); } } else if (body.contains("Clearspace Upgrade Console")) { // TODO Change CS to send a more standard error message throw new ConnectionException( "Clearspace is in an update state.", ConnectionException.ErrorType.UPDATE_STATE); } Element response = localParser.get().parseDocument(body).getRootElement(); // Check for exceptions checkFault(response); // Since there is no exception, returns the response return response; } catch (DocumentException e) { throw new ConnectionException( "Error parsing the response of Clearspace.", e, ConnectionException.ErrorType.OTHER); } catch (HttpException e) { throw new ConnectionException( "Error performing http request to Clearspace", e, ConnectionException.ErrorType.OTHER); } catch (UnknownHostException e) { throw new ConnectionException( "Unknown Host " + getConnectionURI() + " trying to connect to Clearspace", e, ConnectionException.ErrorType.UNKNOWN_HOST); } catch (IOException e) { throw new ConnectionException( "Error peforming http request to Clearspace.", e, ConnectionException.ErrorType.OTHER); } finally { method.releaseConnection(); } }
String getConfigureInformation( String dataId, String group, long timeout, boolean skipContentCache) { start(); if (!isRun) { throw new RuntimeException( "DiamondSubscriber is not running, so can't fetch from ConfigureInformation"); } if (null == group) { group = Constants.DEFAULT_GROUP; } // =======================ʹ�ò���ģʽ======================= if (MockServer.isTestMode()) { return MockServer.getConfigInfo(dataId, group); } if (!skipContentCache) { String key = makeCacheKey(dataId, group); String content = contentCache.get(key); if (content != null) { return content; } } long waitTime = 0; String uri = getUriString(dataId, group); if (log.isInfoEnabled()) { log.info(uri); } CacheData cacheData = getCacheData(dataId, group); int retryTimes = this.getDiamondConfigure().getRetrieveDataRetryTimes(); log.info("Retry times is " + retryTimes); int tryCount = 0; while (0 == timeout || timeout > waitTime) { tryCount++; if (tryCount > retryTimes + 1) { log.warn("Retry time reach the limit, so break"); break; } log.info("Fetch config " + tryCount + "times, waitTime:" + waitTime); long onceTimeOut = getOnceTimeOut(waitTime, timeout); waitTime += onceTimeOut; HttpMethod httpMethod = new GetMethod(uri); configureHttpMethod(skipContentCache, cacheData, onceTimeOut, httpMethod); try { int httpStatus = httpClient.executeMethod(httpMethod); switch (httpStatus) { case SC_OK: { String result = getSuccess(dataId, group, cacheData, httpMethod); return result; } case SC_NOT_MODIFIED: { String result = getNotModified(dataId, cacheData, httpMethod); return result; } case SC_NOT_FOUND: { log.warn("DataID:" + dataId + "not found"); cacheData.setMd5(Constants.NULL); this.snapshotConfigInfoProcessor.removeSnapshot(dataId, group); return null; } case SC_SERVICE_UNAVAILABLE: { rotateToNextDomain(); } break; default: { log.warn("HTTP State: " + httpStatus + ":" + httpClient.getState()); rotateToNextDomain(); } } } catch (HttpException e) { log.error("Fetch config HttpException", e); rotateToNextDomain(); } catch (IOException e) { log.error("Fetch config IOException", e); rotateToNextDomain(); } catch (Exception e) { log.error("Unknown Exception", e); rotateToNextDomain(); } finally { httpMethod.releaseConnection(); } } throw new RuntimeException( "Fetch config timeout, DataID=" + dataId + ", Group=" + group + ",timeout=" + timeout); }
private static boolean isFormAvailable(Request request, TypedData body) { HttpMethod method = request.getMethod(); return body.getContentType().isForm() && (method.isPost() || method.isPut()); }
public ResourceMethod(MethodDeclaration delegate, Resource parent) { super(delegate); Set<String> httpMethods = new TreeSet<String>(); Collection<AnnotationMirror> mirrors = delegate.getAnnotationMirrors(); for (AnnotationMirror mirror : mirrors) { AnnotationTypeDeclaration annotationDeclaration = mirror.getAnnotationType().getDeclaration(); HttpMethod httpMethodInfo = annotationDeclaration.getAnnotation(HttpMethod.class); if (httpMethodInfo != null) { // request method designator found. httpMethods.add(httpMethodInfo.value()); } } if (httpMethods.isEmpty()) { throw new IllegalStateException( "A resource method must specify an HTTP method by using a request method designator annotation."); } this.httpMethods = httpMethods; Set<String> consumes; Consumes consumesInfo = delegate.getAnnotation(Consumes.class); if (consumesInfo != null) { consumes = new TreeSet<String>(Arrays.asList(JAXRSUtils.value(consumesInfo))); } else { consumes = new TreeSet<String>(parent.getConsumesMime()); } this.consumesMime = consumes; Set<String> produces; Produces producesInfo = delegate.getAnnotation(Produces.class); if (producesInfo != null) { produces = new TreeSet<String>(Arrays.asList(JAXRSUtils.value(producesInfo))); } else { produces = new TreeSet<String>(parent.getProducesMime()); } this.producesMime = produces; String subpath = null; Path pathInfo = delegate.getAnnotation(Path.class); if (pathInfo != null) { subpath = pathInfo.value(); } ResourceEntityParameter entityParameter; List<ResourceEntityParameter> declaredEntityParameters = new ArrayList<ResourceEntityParameter>(); List<ResourceParameter> resourceParameters; ResourceRepresentationMetadata outputPayload; ResourceMethodSignature signatureOverride = delegate.getAnnotation(ResourceMethodSignature.class); if (signatureOverride == null) { entityParameter = null; resourceParameters = new ArrayList<ResourceParameter>(); // if we're not overriding the signature, assume we use the real method signature. for (ParameterDeclaration parameterDeclaration : getParameters()) { if (ResourceParameter.isResourceParameter(parameterDeclaration)) { resourceParameters.add(new ResourceParameter(parameterDeclaration)); } else if (ResourceParameter.isFormBeanParameter(parameterDeclaration)) { resourceParameters.addAll(ResourceParameter.getFormBeanParameters(parameterDeclaration)); } else if (parameterDeclaration.getAnnotation(Context.class) == null) { entityParameter = new ResourceEntityParameter(this, parameterDeclaration); declaredEntityParameters.add(entityParameter); } } DecoratedTypeMirror returnTypeMirror; TypeHint hintInfo = getAnnotation(TypeHint.class); if (hintInfo != null) { try { Class hint = hintInfo.value(); AnnotationProcessorEnvironment env = net.sf.jelly.apt.Context.getCurrentEnvironment(); if (TypeHint.NO_CONTENT.class.equals(hint)) { returnTypeMirror = (DecoratedTypeMirror) TypeMirrorDecorator.decorate(env.getTypeUtils().getVoidType()); } else { String hintName = hint.getName(); if (TypeHint.NONE.class.equals(hint)) { hintName = hintInfo.qualifiedName(); } if (!"##NONE".equals(hintName)) { TypeDeclaration type = env.getTypeDeclaration(hintName); returnTypeMirror = (DecoratedTypeMirror) TypeMirrorDecorator.decorate(env.getTypeUtils().getDeclaredType(type)); } else { returnTypeMirror = (DecoratedTypeMirror) getReturnType(); } } } catch (MirroredTypeException e) { returnTypeMirror = (DecoratedTypeMirror) TypeMirrorDecorator.decorate(e.getTypeMirror()); } returnTypeMirror.setDocComment(((DecoratedTypeMirror) getReturnType()).getDocComment()); } else { returnTypeMirror = (DecoratedTypeMirror) getReturnType(); if (getJavaDoc().get("returnWrapped") != null) { // support jax-doclets. see http://jira.codehaus.org/browse/ENUNCIATE-690 String fqn = getJavaDoc().get("returnWrapped").get(0); AnnotationProcessorEnvironment env = net.sf.jelly.apt.Context.getCurrentEnvironment(); TypeDeclaration type = env.getTypeDeclaration(fqn); if (type != null) { returnTypeMirror = (DecoratedTypeMirror) TypeMirrorDecorator.decorate(env.getTypeUtils().getDeclaredType(type)); } } // in the case where the return type is com.sun.jersey.api.JResponse, // we can use the type argument to get the entity type if (returnTypeMirror.isClass() && returnTypeMirror.isInstanceOf("com.sun.jersey.api.JResponse")) { DecoratedClassType jresponse = (DecoratedClassType) returnTypeMirror; if (!jresponse.getActualTypeArguments().isEmpty()) { DecoratedTypeMirror responseType = (DecoratedTypeMirror) TypeMirrorDecorator.decorate( jresponse.getActualTypeArguments().iterator().next()); if (responseType.isDeclared()) { responseType.setDocComment(returnTypeMirror.getDocComment()); returnTypeMirror = responseType; } } } } outputPayload = returnTypeMirror.isVoid() ? null : new ResourceRepresentationMetadata(returnTypeMirror); } else { entityParameter = loadEntityParameter(signatureOverride); declaredEntityParameters.add(entityParameter); resourceParameters = loadResourceParameters(signatureOverride); outputPayload = loadOutputPayload(signatureOverride); } JavaDoc.JavaDocTagList doclets = getJavaDoc() .get( "RequestHeader"); // support jax-doclets. see // http://jira.codehaus.org/browse/ENUNCIATE-690 if (doclets != null) { for (String doclet : doclets) { int firstspace = doclet.indexOf(' '); String header = firstspace > 0 ? doclet.substring(0, firstspace) : doclet; String doc = ((firstspace > 0) && (firstspace + 1 < doclet.length())) ? doclet.substring(firstspace + 1) : ""; resourceParameters.add( new ExplicitResourceParameter(this, doc, header, ResourceParameterType.HEADER)); } } ArrayList<ResponseCode> statusCodes = new ArrayList<ResponseCode>(); ArrayList<ResponseCode> warnings = new ArrayList<ResponseCode>(); StatusCodes codes = getAnnotation(StatusCodes.class); if (codes != null) { for (org.codehaus.enunciate.jaxrs.ResponseCode code : codes.value()) { ResponseCode rc = new ResponseCode(); rc.setCode(code.code()); rc.setCondition(code.condition()); statusCodes.add(rc); } } doclets = getJavaDoc() .get("HTTP"); // support jax-doclets. see http://jira.codehaus.org/browse/ENUNCIATE-690 if (doclets != null) { for (String doclet : doclets) { int firstspace = doclet.indexOf(' '); String code = firstspace > 0 ? doclet.substring(0, firstspace) : doclet; String doc = ((firstspace > 0) && (firstspace + 1 < doclet.length())) ? doclet.substring(firstspace + 1) : ""; try { ResponseCode rc = new ResponseCode(); rc.setCode(Integer.parseInt(code)); rc.setCondition(doc); statusCodes.add(rc); } catch (NumberFormatException e) { // fall through... } } } Warnings warningInfo = getAnnotation(Warnings.class); if (warningInfo != null) { for (org.codehaus.enunciate.jaxrs.ResponseCode code : warningInfo.value()) { ResponseCode rc = new ResponseCode(); rc.setCode(code.code()); rc.setCondition(code.condition()); warnings.add(rc); } } codes = parent.getAnnotation(StatusCodes.class); if (codes != null) { for (org.codehaus.enunciate.jaxrs.ResponseCode code : codes.value()) { ResponseCode rc = new ResponseCode(); rc.setCode(code.code()); rc.setCondition(code.condition()); statusCodes.add(rc); } } warningInfo = parent.getAnnotation(Warnings.class); if (warningInfo != null) { for (org.codehaus.enunciate.jaxrs.ResponseCode code : warningInfo.value()) { ResponseCode rc = new ResponseCode(); rc.setCode(code.code()); rc.setCondition(code.condition()); warnings.add(rc); } } ResponseHeaders responseHeaders = parent.getAnnotation(ResponseHeaders.class); if (responseHeaders != null) { for (ResponseHeader header : responseHeaders.value()) { this.responseHeaders.put(header.name(), header.description()); } } responseHeaders = getAnnotation(ResponseHeaders.class); if (responseHeaders != null) { for (ResponseHeader header : responseHeaders.value()) { this.responseHeaders.put(header.name(), header.description()); } } doclets = getJavaDoc() .get( "ResponseHeader"); // support jax-doclets. see // http://jira.codehaus.org/browse/ENUNCIATE-690 if (doclets != null) { for (String doclet : doclets) { int firstspace = doclet.indexOf(' '); String header = firstspace > 0 ? doclet.substring(0, firstspace) : doclet; String doc = ((firstspace > 0) && (firstspace + 1 < doclet.length())) ? doclet.substring(firstspace + 1) : ""; this.responseHeaders.put(header, doc); } } this.entityParameter = entityParameter; this.resourceParameters = resourceParameters; this.subpath = subpath; this.parent = parent; this.statusCodes = statusCodes; this.warnings = warnings; this.representationMetadata = outputPayload; this.declaredEntityParameters = declaredEntityParameters; }