下面列出了org.apache.http.NameValuePair#getValue ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
public static String getFileNameFromHttpResponse(final HttpResponse response) {
if (response == null) return null;
String result = null;
Header header = response.getFirstHeader("Content-Disposition");
if (header != null) {
for (HeaderElement element : header.getElements()) {
NameValuePair fileNamePair = element.getParameterByName("filename");
if (fileNamePair != null) {
result = fileNamePair.getValue();
// try to get correct encoding str
result = CharsetUtils.toCharset(result, HTTP.UTF_8, result.length());
break;
}
}
}
return result;
}
public static String getSign(List<NameValuePair> params) {
ArrayList<String> list = new ArrayList<String>();
StringBuilder sb = new StringBuilder();
for(NameValuePair pair:params){
if (pair.getValue()!=""&& !pair.getValue().equalsIgnoreCase("sign"))
list.add(pair.getName() + "=" + pair.getValue() + "&");
}
int size = list.size();
String [] arrayToSort = list.toArray(new String[size]);
Arrays.sort(arrayToSort, String.CASE_INSENSITIVE_ORDER);
for(int i = 0; i < size; i ++) {
sb.append(arrayToSort[i]);
}
String result = sb.toString();
result += "key=" +KEY;
byte[] data=null;
try {
data = result.getBytes("utf-8");
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
String appSign = MD5Util.sign(data).toUpperCase();
return appSign;
}
public String getNextCursorFromDocument(JSONAPIDocument document) {
Links links = document.getLinks();
if (links == null) {
return null;
}
Link nextLink = links.getNext();
if (nextLink == null) {
return null;
}
String nextLinkString = nextLink.toString();
try {
List<NameValuePair> queryParameters = URLEncodedUtils.parse(new URI(nextLinkString), "utf8");
for (NameValuePair pair : queryParameters) {
String name = pair.getName();
if (name.equals("page[cursor]")) {
return pair.getValue();
}
}
} catch (URISyntaxException e) {
LOG.error(e.getMessage());
}
return null;
}
public static String getContentTypeVal(Header header) {
System.out.println("[DEBUG] HEADER: " + header);
for (HeaderElement el : header.getElements()) {
NameValuePair cTypePair = el.getParameterByName("Content-Type");
if (cTypePair != null && !cTypePair.getValue().isEmpty()) {
return cTypePair.getValue();
}
}
int index = header.toString().indexOf("Content-Type");
if (index >= 0) {
String ret = header.toString().substring(index + "Content-Type".length() + 1);
if (ret.contains(";")) {
return ret.substring(0, ret.indexOf(";")).trim();
}
return ret.trim();
}
return "application/sparql-results+json";
}
@GetMapping(produces = "application/json")
public ResultListDataRepresentation getCaseModels(HttpServletRequest request) {
// need to parse the filterText parameter ourselves, due to encoding issues with the default parsing.
String filter = null;
String excludeId = null;
List<NameValuePair> params = URLEncodedUtils.parse(request.getQueryString(), Charset.forName("UTF-8"));
if (params != null) {
for (NameValuePair nameValuePair : params) {
if ("filter".equalsIgnoreCase(nameValuePair.getName())) {
filter = nameValuePair.getValue();
} else if ("excludeId".equalsIgnoreCase(nameValuePair.getName())) {
excludeId = nameValuePair.getValue();
}
}
}
return caseService.getCases(filter, excludeId);
}
/**
* copy: EntityUtils Obtains character set of the entity, if known.
*
* @param entity must not be null
* @return the character set, or null if not found
* @throws ParseException if header elements cannot be parsed
* @throws IllegalArgumentException if entity is null
*/
private static String getContentCharSet(final HttpEntity entity) throws ParseException {
if (entity == null) {
throw new IllegalArgumentException("HTTP entity must not be null");
}
String charset = null;
if (entity.getContentType() != null) {
HeaderElement values[] = entity.getContentType().getElements();
if (values.length > 0) {
NameValuePair param = values[0].getParameterByName("charset");
if (param != null) {
charset = param.getValue();
}
}
}
return charset;
}
public void consume(Map<String, String> result) throws IOException {
if (httpResponse.getEntity() != null) {
if (responseCharacterSet == null || responseCharacterSet.isEmpty()) {
Header contentType = httpResponse.getEntity().getContentType();
if (contentType != null) {
String value = contentType.getValue();
NameValuePair[] nameValuePairs = BasicHeaderValueParser.parseParameters(value, BasicHeaderValueParser.INSTANCE);
for (NameValuePair nameValuePair : nameValuePairs) {
if (nameValuePair.getName().equalsIgnoreCase("charset")) {
responseCharacterSet = nameValuePair.getValue();
break;
}
}
}
if (responseCharacterSet == null || responseCharacterSet.isEmpty()) {
responseCharacterSet = Consts.ISO_8859_1.name();
}
}
consumeResponseContent(result);
}
}
protected String getAttachmentFileName(org.apache.http.HttpResponse resp) {
String fileName = null;
Header[] contentDisp = resp.getHeaders("content-disposition");
if (contentDisp != null && contentDisp.length > 0) {
HeaderElement[] headerElements = contentDisp[0].getElements();
if (headerElements != null) {
for (HeaderElement headerElement : headerElements) {
if ("attachment".equals(headerElement.getName())) {
NameValuePair param = headerElement.getParameterByName("filename");
if (param != null) {
fileName = param.getValue();
break;
}
}
}
}
}
return fileName;
}
@VisibleForTesting
static String getDoAs(HttpServletRequest request) {
List<NameValuePair> list = URLEncodedUtils.parse(request.getQueryString(),
UTF8_CHARSET);
if (list != null) {
for (NameValuePair nv : list) {
if (DelegationTokenAuthenticatedURL.DO_AS.
equalsIgnoreCase(nv.getName())) {
return nv.getValue();
}
}
}
return null;
}
public ResultListDataRepresentation getModels(String filter, String sort, Integer modelType, HttpServletRequest request) {
// need to parse the filterText parameter ourselves, due to encoding issues with the default parsing.
String filterText = null;
List<NameValuePair> params = URLEncodedUtils.parse(request.getQueryString(), Charset.forName("UTF-8"));
if (params != null) {
for (NameValuePair nameValuePair : params) {
if ("filterText".equalsIgnoreCase(nameValuePair.getName())) {
filterText = nameValuePair.getValue();
}
}
}
List<ModelRepresentation> resultList = new ArrayList<>();
List<Model> models = null;
String validFilter = makeValidFilterText(filterText);
if (validFilter != null) {
models = modelRepository.findByModelTypeAndFilter(modelType, validFilter, sort);
} else {
models = modelRepository.findByModelType(modelType, sort);
}
if (CollectionUtils.isNotEmpty(models)) {
List<String> addedModelIds = new ArrayList<>();
for (Model model : models) {
if (!addedModelIds.contains(model.getId())) {
addedModelIds.add(model.getId());
ModelRepresentation representation = createModelRepresentation(model);
resultList.add(representation);
}
}
}
ResultListDataRepresentation result = new ResultListDataRepresentation(resultList);
return result;
}
private void loadParams(URI uri, Properties props) throws SQLException {
List<NameValuePair> parsedParams = URLEncodedUtils.parse(uri, "UTF-8");
for (NameValuePair pair : parsedParams) {
if (pair.getValue() != null) {
props.put(pair.getName(), pair.getValue());
} else {
props.put(pair.getName(), "");
}
}
}
@RequestMapping(method = RequestMethod.GET, produces = "application/json")
public ResultListDataRepresentation getDecisionTables(HttpServletRequest request) {
// need to parse the filterText parameter ourselves, due to encoding issues with the default parsing.
String filter = null;
List<NameValuePair> params = URLEncodedUtils.parse(request.getQueryString(), Charset.forName("UTF-8"));
if (params != null) {
for (NameValuePair nameValuePair : params) {
if ("filter".equalsIgnoreCase(nameValuePair.getName())) {
filter = nameValuePair.getValue();
}
}
}
return decisionTableService.getDecisionTables(filter);
}
private long connect(long timeMillis) throws IOException
{
String uriStr = fsRecoveryHandler.readConnectUri();
if (!uriStr.equals(lastConnectURI)) {
LOG.debug("Got new RPC connect address {}", uriStr);
lastConnectURI = uriStr;
if (umbilical != null) {
RPC.stopProxy(umbilical);
}
retryTimeoutMillis = Long.getLong(RETRY_TIMEOUT, RETRY_TIMEOUT_DEFAULT);
retryDelayMillis = Long.getLong(RETRY_DELAY, RETRY_DELAY_DEFAULT);
rpcTimeout = Integer.getInteger(RPC_TIMEOUT, RPC_TIMEOUT_DEFAULT);
URI heartbeatUri = URI.create(uriStr);
String queryStr = heartbeatUri.getQuery();
if (queryStr != null) {
List<NameValuePair> queryList = URLEncodedUtils.parse(queryStr, Charset.defaultCharset());
if (queryList != null) {
for (NameValuePair pair : queryList) {
String value = pair.getValue();
String key = pair.getName();
if (QP_rpcTimeout.equals(key)) {
this.rpcTimeout = Integer.parseInt(value);
} else if (QP_retryTimeoutMillis.equals(key)) {
this.retryTimeoutMillis = Long.parseLong(value);
} else if (QP_retryDelayMillis.equals(key)) {
this.retryDelayMillis = Long.parseLong(value);
}
}
}
}
InetSocketAddress address = NetUtils.createSocketAddrForHost(heartbeatUri.getHost(), heartbeatUri.getPort());
umbilical = RPC.getProxy(StreamingContainerUmbilicalProtocol.class, StreamingContainerUmbilicalProtocol.versionID, address, currentUser, conf, defaultSocketFactory, rpcTimeout);
// reset timeout
return System.currentTimeMillis() + retryTimeoutMillis;
}
return timeMillis;
}
protected String getParameter(List<NameValuePair> nameValuePairs, String param) {
for (NameValuePair nameValuePair : nameValuePairs) {
if (Objects.equal(param, nameValuePair.getName())) {
return nameValuePair.getValue();
}
}
return null;
}
public static String getDoAsUser(HttpServletRequest request) {
if (StringUtils.isNoneEmpty(request.getQueryString())) {
List<NameValuePair> list = URLEncodedUtils.parse(request.getQueryString(), UTF8_CHARSET);
if (list != null) {
for (NameValuePair nv : list) {
if (DO_AS.equals(nv.getName())) {
return nv.getValue();
}
}
}
}
return null;
}
private static String getHttpParam(HttpServletRequest request, String param) {
List<NameValuePair> pairs = URLEncodedUtils.parse(request.getQueryString(), Charset.forName("UTF-8"));
for (NameValuePair nvp : pairs) {
if (param.equals(nvp.getName())) {
return nvp.getValue();
}
}
return null;
}
public String parametersAsQueryString() {
String s = "";
for (Iterator<NameValuePair> i = this.params.iterator(); i.hasNext(); ) {
NameValuePair nv = i.next();
s += "&" + nv.getName() + "=" + nv.getValue();
}
if (s.length() > 0) {
return "?" + s.substring(1);
}
return s;
}
public static String getParameter(DriverRequest request, String name) {
String characterEncoding = request.getCharacterEncoding();
if (characterEncoding == null) {
characterEncoding = "ISO-8859-1";
}
List<NameValuePair> parameters =
UriUtils.parse(request.getOriginalRequest().getRequestLine().getUri(), characterEncoding);
for (NameValuePair nameValuePair : parameters) {
if (nameValuePair.getName().equals(name)) {
return nameValuePair.getValue();
}
}
return null;
}
/**
* Basic filter to remove query parameters from urls so parameters that
* don't change the content of the page can be removed. An example would be
* a google analytics query parameter like "utm_campaign" which might have
* several different values for a url that points to the same content. This
* is also called when removing attributes where the value is a hash.
*/
private String processQueryElements(String urlToFilter) {
try {
// Handle illegal characters by making a url first
// this will clean illegal characters like |
URL url = new URL(urlToFilter);
String path = url.getPath();
String query = url.getQuery();
// check if the last element of the path contains parameters
// if so convert them to query elements
if (path.contains(";")) {
String[] pathElements = path.split("/");
String last = pathElements[pathElements.length - 1];
// replace last value by part without params
int semicolon = last.indexOf(";");
if (semicolon != -1) {
pathElements[pathElements.length - 1] = last.substring(0,
semicolon);
String params = last.substring(semicolon + 1).replaceAll(
";", "&");
if (query == null) {
query = params;
} else {
query += "&" + params;
}
// rebuild the path
StringBuilder newPath = new StringBuilder();
for (String p : pathElements) {
if (StringUtils.isNotBlank(p)) {
newPath.append("/").append(p);
}
}
path = newPath.toString();
}
}
if (StringUtils.isEmpty(query)) {
return urlToFilter;
}
List<NameValuePair> pairs = URLEncodedUtils.parse(query, StandardCharsets.UTF_8);
Iterator<NameValuePair> pairsIterator = pairs.iterator();
while (pairsIterator.hasNext()) {
NameValuePair param = pairsIterator.next();
if (queryElementsToRemove.contains(param.getName())) {
pairsIterator.remove();
} else if (removeHashes && param.getValue() != null) {
Matcher m = thirtytwobithash.matcher(param.getValue());
if (m.matches()) {
pairsIterator.remove();
}
}
}
StringBuilder newFile = new StringBuilder();
if (StringUtils.isNotBlank(path)) {
newFile.append(path);
}
if (!pairs.isEmpty()) {
Collections.sort(pairs, parametersComparator);
String newQueryString = URLEncodedUtils.format(pairs,
StandardCharsets.UTF_8);
newFile.append('?').append(newQueryString);
}
if (url.getRef() != null) {
newFile.append('#').append(url.getRef());
}
return new URL(url.getProtocol(), url.getHost(), url.getPort(),
newFile.toString()).toString();
} catch (MalformedURLException e) {
LOG.warn("Invalid urlToFilter {}. {}", urlToFilter, e);
return null;
}
}
public static ParsedUrl parseUrl(String url) {
List<PathPart> pathParts = new ArrayList<PathPart>();
List<Query> queries = new ArrayList<Query>();
ParsedUrl parsedUrl;
String base;
try {
URL aURL = new URL(url);
base = aURL.getAuthority();
String protocol = aURL.getProtocol();
parsedUrl = new ParsedUrl();
parsedUrl.setPathWithEndingSlash(aURL.getPath().endsWith("/"));
parsedUrl.setBaseUrl(protocol + "://" + base);
List<NameValuePair> pairs = URLEncodedUtils.parse(aURL.getQuery(),
Charset.defaultCharset());
for (NameValuePair pair : pairs) {
Query query = new Query(pair.getName(), pair.getValue());
queries.add(query);
}
parsedUrl.setQueries(queries);
String[] pathStrings = aURL.getPath().split("/");
for (String pathPart : pathStrings) {
Matcher m = PATH_PARAM_PATTERN.matcher(pathPart);
if (m.find()) {
String paramDef = m.group(1);
String[] paramParts = paramDef.split(":");
if (paramParts.length > 1) {
pathParts.add(new PathPart(paramParts[1].trim(), paramParts[0].trim()));
} else {
pathParts.add(new PathPart(paramParts[0].trim()));
}
} else {
if(!pathPart.isEmpty()) {
pathParts.add(new PathPart(pathPart));
}
}
}
parsedUrl.setPathParts(pathParts);
} catch (Exception ex) {
Logger.error(UrlParser.class, R2MMessages.getMessage("CANNOT_PARSE_URL", url));
return null;
}
return parsedUrl;
}