How to use

getParameters

method

in

org.jboss.netty.handler.codec.http.QueryStringDecoder

 new QueryStringDecoder(request.getUri()).getParameters();
final List<String> keepAliveList = q.get("keepAlive");
boolean keepAliveParam = false;

public Map<String, String> params() {
 if (params == null) {
  QueryStringDecoder queryStringDecoder = new QueryStringDecoder(uri);
  Map<String, List<String>> prms = queryStringDecoder.getParameters();
  if (prms.isEmpty()) {
   params = new HashMap<>();
  } else {
   params = new HashMap<>(prms.size());
   for (Map.Entry<String, List<String>> entry: prms.entrySet()) {
    params.put(entry.getKey(), entry.getValue().get(0));
   }
  }
 }
 return params;
}

 private ResourceStatus getStatusParam(HttpRequest request) throws IllegalArgumentException {
  Map<String, List<String>> queryParams = new QueryStringDecoder(request.getUri()).getParameters();
  return queryParams.containsKey("status") ?
   ResourceStatus.valueOf(queryParams.get("status").get(0).toUpperCase()) : null;
 }
}

 /**
  * Retrieves query parameters from {@code request}.
  *
  * @param request the request
  * @param names list of query parameters names
  * @return {@link Map} of query parameters
  */
 private Map<String, String> getFilters(HttpRequest request, List<String> names) {
  Map<String, List<String>> queryParams = new QueryStringDecoder(request.getUri()).getParameters();
  Map<String, String> filters = Maps.newHashMap();
  for (String name : names) {
   List<String> values = queryParams.get(name);
   if (values != null && !values.isEmpty()) {
    filters.put(name, values.get(0));
   }
  }

  return filters;
 }
}

 private Set<Cluster.Status> getStatusFilter(HttpRequest request) {
  Set<Cluster.Status> filter = Sets.newHashSet();
  Map<String, List<String>> queryParams = new QueryStringDecoder(request.getUri()).getParameters();
  List<String> statusParams = queryParams.get("status");
  if (statusParams != null && !statusParams.isEmpty()) {
   String statusStr = queryParams.get("status").get(0);
   String[] statuses = statusStr.split(",");
   for (String status: statuses) {
    try {
     filter.add(Cluster.Status.valueOf(status.toUpperCase()));
    } catch (IllegalArgumentException e) {
     LOG.info("Unknown cluster status {} requested.", status);
    }
   }
  }
  return filter;
 }
}

/**
 * Returns the query string parameters passed in the URI.
 */
public Map<String, List<String>> getQueryString() {
  if (querystring == null) {
    try {
      querystring = new QueryStringDecoder(request.getUri()).getParameters();
    } catch (IllegalArgumentException e) {
      throw new BadRequestException("Bad query string: " + e.getMessage());
    }
  }
  return querystring;
}

@Override
public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
  HttpRequest request = (HttpRequest) e.getMessage();
  QueryStringDecoder qsd = new QueryStringDecoder(request.getUri());
  final List<String> c = qsd.getParameters().get("c");
  if (c == null) {
    respond(e.getChannel(), HttpResponseStatus.INTERNAL_SERVER_ERROR, "\"callback\" parameter required.");
    return;
  }
  jsonpCallback = c.get(0);
  super.messageReceived(ctx, e);
}

protected List<ApplicationInfo> filterClientApps(HttpRequest req, List<ApplicationInfo> apps) {
  List<ApplicationInfo> filteredApps = new ArrayList<ApplicationInfo>();
  QueryStringDecoder dec = new QueryStringDecoder(req.getUri());
  Map<String, List<String>> params = dec.getParameters();
  if (params != null) {
    String status = QueryParameter.getFirstElement(params, "status");
    Integer statusInt = null;
    if (status != null && !status.isEmpty()) {
      try {
        statusInt = Integer.valueOf(status);
        for (ApplicationInfo app : apps) {
          if (app.getStatus() == statusInt) {
            filteredApps.add(app);
          }
        }
      } catch (NumberFormatException e) {
        // status is invalid, ignore it
        filteredApps = Collections.unmodifiableList(apps);
      }
    } else {
      filteredApps = Collections.unmodifiableList(apps);
    }
  }
  return filteredApps;
}

@Override
public boolean decode(Channel channel) throws Exception {
  HttpChannelConfig httpConfig = (HttpChannelConfig) channel.getConfig();
  QueryStringDecoder query = httpConfig.getReadQuery();
  Map<String, List<String>> parameters = query.getParameters();
  List<String> parameterValues = parameters.get(name);
  if (valueDecoders.size() == 1) {
    MessageDecoder valueDecoder = valueDecoders.get(0);
    decodeParameterValue(parameters, parameterValues, valueDecoder);
  }
  else {
    for (MessageDecoder valueDecoder : valueDecoders) {
      decodeParameterValue(parameters, parameterValues, valueDecoder);
    }
  }
  return true;
}

new QueryStringDecoder(request.getUri()).getParameters();

public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
  HttpRequest request = (HttpRequest) e.getMessage();
  QueryStringDecoder qsd = new QueryStringDecoder(request.getUri());
  final List<String> c = qsd.getParameters().get("c");
  if (c == null) {
    respond(e.getChannel(), HttpResponseStatus.INTERNAL_SERVER_ERROR, "\"callback\" parameter required.");
    return;
  }
  final String callback = c.get(0);
  header = ChannelBuffers.wrappedBuffer(HEADER_PART1, ChannelBuffers.copiedBuffer(callback, CharsetUtil.UTF_8), HEADER_PART2);
  super.messageReceived(ctx, e);
}

/**
 * Returns either all scopes or scopes for a specific client_id passed as query parameter.
 *
 * @param req request
 * @return string If query param client_id is passed, then the scopes for that client_id will be returned.
 * Otherwise, all available scopes will be returned in JSON format.
 */
public String getScopes(HttpRequest req) throws OAuthException {
  QueryStringDecoder dec = new QueryStringDecoder(req.getUri());
  Map<String, List<String>> queryParams = dec.getParameters();
  if(queryParams.containsKey("client_id")) {
    return getScopes(queryParams.get("client_id").get(0));
  }
  List<Scope> scopes = DBManagerFactory.getInstance().getAllScopes();
  ObjectMapper mapper = new ObjectMapper();
  String jsonString;
  try {
    jsonString = mapper.writeValueAsString(scopes);
  } catch (JsonGenerationException e) {
    log.error("cannot load scopes", e);
    throw new OAuthException(e, null, HttpResponseStatus.BAD_REQUEST);
  } catch (JsonMappingException e) {
    log.error("cannot load scopes", e);
    throw new OAuthException(e, null, HttpResponseStatus.BAD_REQUEST);
  } catch (IOException e) {
    log.error("cannot load scopes", e);
    throw new OAuthException(e, null, HttpResponseStatus.BAD_REQUEST);
  }
  return jsonString;
}

protected HttpResponse handleTokenValidate(HttpRequest req) {
  HttpResponse response = null;
  QueryStringDecoder dec = new QueryStringDecoder(req.getUri());
  Map<String, List<String>> params = dec.getParameters();
  String tokenParam = QueryParameter.getFirstElement(params, QueryParameter.TOKEN);
  if (tokenParam == null || tokenParam.isEmpty()) {
    response = Response.createBadRequestResponse();
  } else {
    AccessToken token = auth.isValidToken(tokenParam);
    if (token != null) {
      Gson gson = new Gson();
      String json = gson.toJson(token);
      log.debug(json);
      response = Response.createOkResponse(json);
    } else {
      response = Response.createUnauthorizedResponse();
    }
  }
  return response;
}

Map<String, List<String>> params = queryStringDecoder.getParameters();
if (!params.isEmpty()) {
  for (Entry<String, List<String>> p: params.entrySet()) {
    Map<String, List<String>> postParams = postDecoder.getParameters();
    if (!postParams.isEmpty()) {
      for (Entry<String, List<String>> p: postParams.entrySet()) {
  Map<String, List<String>> postParams = postDecoder.getParameters();
  if (!postParams.isEmpty()) {
    for (Entry<String, List<String>> p: postParams.entrySet()) {

  protected HttpResponse handleGetAccessTokens(HttpRequest req) {
    HttpResponse response = null;
    QueryStringDecoder dec = new QueryStringDecoder(req.getUri());
    Map<String, List<String>> params = dec.getParameters();
    String clientId = QueryParameter.getFirstElement(params, QueryParameter.CLIENT_ID);
    String userId = QueryParameter.getFirstElement(params, QueryParameter.USER_ID);
    if (clientId == null || clientId.isEmpty()) {
      response = Response.createBadRequestResponse(String.format(Response.MANDATORY_PARAM_MISSING, QueryParameter.CLIENT_ID));
    } else if (userId == null || userId.isEmpty()) {
      response = Response.createBadRequestResponse(String.format(Response.MANDATORY_PARAM_MISSING, QueryParameter.USER_ID));
    } else {
      // check that clientId exists, no matter whether it is active or not
      if (!auth.isExistingClient(clientId)) {
        response = Response.createBadRequestResponse(Response.INVALID_CLIENT_ID);
      } else {
        List<AccessToken> accessTokens = DBManagerFactory.getInstance().getAccessTokenByUserIdAndClientApp(userId, clientId);
        Gson gson = new Gson();
        String jsonString = gson.toJson(accessTokens);
        response = Response.createOkResponse(jsonString);
      }
    }
    return response;
  }
}

  new QueryStringDecoder(request.getUri()).getParameters();
final List<String> mapIds = splitMaps(q.get("map"));
final List<String> reduceQ = q.get("reduce");

new QueryStringDecoder(request.getUri()).getParameters();

public AuthRequest(HttpRequest request) {
  if (request.getUri() != null) {
    QueryStringDecoder dec = new QueryStringDecoder(request.getUri());
    Map<String, List<String>> params = dec.getParameters();
    this.clientId = QueryParameter.getFirstElement(params, CLIENT_ID);
    this.responseType = QueryParameter.getFirstElement(params, RESPONSE_TYPE);
    this.redirectUri = QueryParameter.getFirstElement(params, REDIRECT_URI);
    this.state = QueryParameter.getFirstElement(params, STATE);
    this.scope = QueryParameter.getFirstElement(params, SCOPE);
    this.userId = QueryParameter.getFirstElement(params, USER_ID);
  }
}

if (BaseTransport.CONTENT_TYPE_FORM.equals(contentTypeHeader)) {
  QueryStringDecoder decoder = new QueryStringDecoder("?" + request.getContent().toString(CharsetUtil.UTF_8));
  List<String> d = decoder.getParameters().get("d");
  if (d == null) {
    BaseTransport.respond(e.getChannel(), INTERNAL_SERVER_ERROR, "Payload expected.");

String message = decoder.getParameters().get("data").get(0);
handleMessage(client, message);