Java Code Examples for javax.servlet.http.HttpServletRequest#getPathInfo()

public void handle(String target, Request baseRequest, HttpServletRequest request,
                   HttpServletResponse response) throws IOException, ServletException {
    response.setContentType("text/html;charset=utf-8");

    //System.out.println("In handler: " + request.getContentLength());

    byte[] bytes = new byte[1024];
    InputStream in = request.getInputStream();
    while (in.read(bytes) > -1) {
        //nothing
    }

    faultRequestPath = request.getPathInfo();
    if ("/faultTo".equals(faultRequestPath)) {
        response.setStatus(HttpServletResponse.SC_ACCEPTED);
    } else {
        response.setStatus(HttpServletResponse.SC_NOT_FOUND);
    }
    PrintWriter writer = response.getWriter();
    writer.println("Received");
    writer.close();
    baseRequest.setHandled(true);
}
 

@Override
public void service(final HttpServletRequest req, final HttpServletResponse resp)
		throws ServletException, IOException {
	final String change = getChangeServerPath();
	if (change != null && change.equals(req.getPathInfo())) {
		try {
			changeServer(req, resp);
		} catch (QueryResultHandlerException e) {
			throw new IOException(e);
		}
	} else {
		final WorkbenchServlet servlet = findWorkbenchServlet(req, resp);
		if (servlet == null) {
			// Redirect to change-server-path
			final StringBuilder uri = new StringBuilder(req.getRequestURI());
			if (req.getPathInfo() != null) {
				uri.setLength(uri.length() - req.getPathInfo().length());
			}
			resp.sendRedirect(uri.append(getChangeServerPath()).toString());
		} else {
			servlet.service(req, resp);
		}
	}
}
 

@GET
@Path("/getImage")
@Produces(MediaType.APPLICATION_JSON)
@UserConstraint(functionalities = { SpagoBIConstants.IMAGES_MANAGEMENT })
public void getImage(@Context HttpServletRequest req, @Context HttpServletResponse resp) {
	try {
		IImagesDAO dao = DAOFactory.getImagesDAO();
		IEngUserProfile profile = (IEngUserProfile) req.getSession().getAttribute(IEngUserProfile.ENG_USER_PROFILE);
		dao.setUserProfile(profile);
		Integer id = Util.getNumberOrNull(req.getParameter("IMAGES_ID"));
		String preview = req.getParameter("preview");
		SbiImages imageDB = dao.loadImage(id);
		String contentType = "";
		byte[] content;
		if (preview != null) {
			content = imageDB.getContentIco();
		} else {
			content = imageDB.getContent();
		}
		flushFileToResponse(resp, contentType, content);
	} catch (Throwable t) {
		logger.error("An unexpected error occured while executing service \"getImage\"", t);
		throw new SpagoBIServiceException(req.getPathInfo(), "An unexpected error occured while executing service \"getImage\"", t);
	}
}
 

/**
 *
 */
public void doGet(HttpServletRequest request, HttpServletResponse response)
		throws IOException, ServletException {
	String lgId = request.getPathInfo();
	OutputStream os = null;

	try {
		if (lgId.length() > 1) {
			Language language = LanguageDAO.findByPk(lgId.substring(1)); // The first character / must be removed

			if (language != null) {
				byte[] img = SecureStore.b64Decode(new String(language.getImageContent()));
				response.setContentType(language.getImageMime());
				response.setContentLength(img.length);
				os = response.getOutputStream();
				os.write(img);
				os.flush();
			}
		}
	} catch (DatabaseException e) {
		log.error(e.getMessage(), e);
	} finally {
		IOUtils.closeQuietly(os);
	}
}
 

/**
 * respond to an HTTP GET request
 * 
 * @param req
 *        HttpServletRequest object with the client request
 * @param res
 *        HttpServletResponse object back to the client
 * @exception ServletException
 *            in case of difficulties
 * @exception IOException
 *            in case of difficulties
 */
public void doGet(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException
{
	// process any login that might be present
	basicAuth.doLogin(req);
	// catch the login helper requests
	String option = req.getPathInfo();
	String[] parts = option.split("/");
	if ((parts.length == 2) && ((parts[1].equals("login"))))
	{
		doLogin(req, res, null);
	}	
	else
	{
		dispatch(req, res);
	}
}
 

@Override
protected void get(HttpServletRequest req, HttpServletResponse resp)
    throws ServletException, IOException {
  String path = req.getPathInfo();
  if (path == null) {
    path = "";
  } else if (path.startsWith("/")) {
    path = path.substring(1);
  }

  if (path.isEmpty()) {
    if (!getComponents().isPresent()) {
      respondWithError(resp, 503, "Unable to load annotator class");
      return;
    }
    respond(resp, MediaType.create("text", "x-yaml"), getComponents().orElse(""));
  } else {
    try {
      Class<?> component = getClassFromString(path, componentPackage);
      List<Map<String, Object>> parameters = getParameters(component);

      respondWithJson(resp, parameters);
    } catch (InvalidParameterException ipe) {
      LoggerFactory.getLogger(clazz).warn("Could not find requested resource", ipe);
      respondWithNotFound(resp);
    }
  }
}
 

@Override
public void service(HttpServletRequest request, HttpServletResponse response) {
    String pathInfo = request.getPathInfo();
    if (pathInfo == null) {
        response.setStatus(HttpServletResponse.SC_NOT_FOUND);
    }
    else {
        try {
            final PluginMetadata pluginMetadata = getPluginMetadataFromPath(pathInfo);
            if (pluginMetadata.isCsrfProtectionEnabled()) {
                if (!passesCsrf(request)) {
                    request.getSession().setAttribute(FlashMessageTag.ERROR_MESSAGE_KEY, LocaleUtils.getLocalizedString("global.csrf.failed"));
                    response.sendRedirect(request.getRequestURI());
                    return;
                }
            }
            // Handle JSP requests.
            if (pathInfo.endsWith(".jsp")) {
                setCSRF(request);
                if (handleDevJSP(pathInfo, request, response)) {
                    return;
                }
                handleJSP(pathInfo, request, response);
            }
            // Handle servlet requests.
            else if (getServlet(pathInfo) != null) {
                setCSRF(request);
                handleServlet(pathInfo, request, response);
            }
            // Handle image/other requests.
            else {
                handleOtherRequest(pathInfo, response);
            }
        }
        catch (Exception e) {
            Log.error(e.getMessage(), e);
            response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
        }
    }
}
 

private void service(final String repoID, final HttpServletRequest req, final HttpServletResponse resp)
		throws RepositoryConfigException, RepositoryException, ServletException, IOException {
	LOGGER.info("Servicing repository: {}", repoID);
	setCredentials(req, resp);
	final DynamicHttpRequest http = new DynamicHttpRequest(req);
	final String path = req.getPathInfo();
	final int idx = path.indexOf(repoID) + repoID.length();
	http.setServletPath(http.getServletPath() + path.substring(0, idx));
	final String pathInfo = path.substring(idx);
	http.setPathInfo(pathInfo.length() == 0 ? null : pathInfo);
	if (repositories.containsKey(repoID)) {
		repositories.get(repoID).service(http, resp);
	} else {
		final Repository repository = manager.getRepository(repoID);
		if (repository == null) {
			final String noId = config.getInitParameter(NO_REPOSITORY);
			if (noId == null || !noId.equals(repoID)) {
				resp.setHeader("Cache-Control", "no-cache, no-store");
				throw new BadRequestException("No such repository: " + repoID);
			}
		}
		final ProxyRepositoryServlet servlet = new ProxyRepositoryServlet();
		servlet.setRepositoryManager(manager);
		if (repository != null) {
			servlet.setRepositoryInfo(manager.getRepositoryInfo(repoID));
			servlet.setRepository(repository);
		}
		servlet.init(new BasicServletConfig(repoID, config));
		repositories.putIfAbsent(repoID, servlet);
		repositories.get(repoID).service(http, resp);
	}
}
 

/**
 * 获得当前的ServletPath
 * @param req
 * @return
 */
public static final String getRecentPath(HttpServletRequest req) {
    String uri = (String) req.getAttribute(RequestDispatcher.INCLUDE_SERVLET_PATH);
    String suf = (String) req.getAttribute(RequestDispatcher.INCLUDE_PATH_INFO);
    if (uri == null) {
        uri  = req.getServletPath();
        suf  = req.getPathInfo();
    }
    if (suf != null) {
        uri += suf;
    }
    return uri;
}
 

@Override
protected StaticResource getStaticResource(HttpServletRequest request) throws IllegalArgumentException {
    final String pathInfo = request.getPathInfo();

    if (pathInfo == null || pathInfo.isEmpty() || "/".equals(pathInfo)) {
        throw new IllegalArgumentException();
    }

    String name = "";
    try {
        name = URLDecoder.decode(pathInfo.substring(1), StandardCharsets.UTF_8.name());
    } catch (UnsupportedEncodingException e) {
        LOGGER.error(e.getMessage());
    }

    final ServletContext context = request.getServletContext();
    final File file = absolute ? new File(directory, name) : new File(context.getRealPath("/"), name).getAbsoluteFile();

    return !file.exists() ? null : new StaticResource() {
        @Override
        public long getLastModified() {
            return file.lastModified();
        }
        @Override
        public InputStream getInputStream() throws IOException {
            return Files.newInputStream(file.toPath());
        }
        @Override
        public String getFileName() {
            return file.getName();
        }
        @Override
        public long getContentLength() {
            return file.length();
        }
    };
}
 

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
  String pathInfo = req.getPathInfo();
  if (CREATE_PATH.equals(pathInfo)) {
    doRegisterGet(req, resp, "");
  } else {
    resp.setStatus(HttpServletResponse.SC_NOT_FOUND);
  }
}
 

@Override
public void doGet(HttpServletRequest request, HttpServletResponse response) {
	try {
		String resourceURI = "META-INF/resources" + request.getServletPath() + request.getPathInfo();
		InputStream inputStream = getResourceAsStream(resourceURI);
		if (inputStream != null) {
			String[] tokens = resourceURI.split("/");
			String fileName = tokens[tokens.length - 1];
			if (!disableCache && tokens.length > 4) {
				String version = tokens[3];
				response.setHeader("ETag", fileName + "_" + version);
				response.setDateHeader("Expires",
						System.currentTimeMillis() + XtextResourcesServlet.DEFAULT_EXPIRE_TIME_MS);
				response.addHeader("Cache-Control",
						("private, max-age=" + XtextResourcesServlet.DEFAULT_EXPIRE_TIME_S));
			}
			String mimeType = getServletContext().getMimeType(fileName);
			String contentType = null;
			if (mimeType != null) {
				contentType = mimeType;
			} else {
				contentType = "application/octet-stream";
			}
			response.setContentType(contentType);
			ByteStreams.copy(inputStream, response.getOutputStream());
		} else {
			response.sendError(HttpServletResponse.SC_NOT_FOUND);
		}
	} catch (IOException e) {
		throw Exceptions.sneakyThrow(e);
	}
}
 

@Override
protected void doGet(MCRServletJob job) throws Exception {
    HttpServletRequest request = job.getRequest();
    String pathInfo = request.getPathInfo();
    HttpServletResponse response = job.getResponse();
    if (pathInfo != null) {
        List<String> splitted = PATH_SPLITTER.splitToList(pathInfo);
        if (splitted.size() == 2) {
            String collection = splitted.get(0);
            String action = splitted.get(1);
            String url = MCRURLRetriever.getURLforCollection(action, collection, true);
            if (url != null) {
                //MCR-1172 check if we redirect to a valid URI
                URI uri = URI.create(url);
                response.sendRedirect(response.encodeRedirectURL(uri.toString()));
            } else {
                response.sendError(HttpServletResponse.SC_NOT_FOUND);
            }
            return;
        }
        //misses action
        response.sendError(HttpServletResponse.SC_BAD_REQUEST);
        return;
    }
    //should never happen:
    response.sendError(HttpServletResponse.SC_PRECONDITION_FAILED);
}
 

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException {

    // Not thread safe
    pathInfo = req.getPathInfo();
}
 

@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

    if (request.getPathInfo().equals("/tickets.json")) {
        String resource = TestUtils.getResourceValue(FakeZendeskAPIServlet.class, "/tickets.json");
        response.getOutputStream().print(resource);
    } else {
        throw new IllegalStateException("Unknown path: " + request.getPathInfo());
    }
}
 

boolean isCacheableResourceRequest(HttpServletRequest request) {
    String requestPath = request.getPathInfo();
    if (requestPath == null) {
        return false;
    }
    for (String resourcePrefix : resourcePrefixes) {
        if (requestPath.startsWith(resourcePrefix)) {
            return true;
        }
    }
    return false;
}
 

@GET
@Path("/")
@Produces(MediaType.APPLICATION_JSON + "; charset=UTF-8")
public String getEngine(@Context HttpServletRequest req) {

	logger.debug("IN");
	try {
		return serializeEngine();
	} catch (Exception e) {
		throw new SpagoBIServiceException(req.getPathInfo(), "An unexpected error occured while executing service", e);
	} finally {
		logger.debug("OUT");
	}
}
 

/**
 * getContextPath and getContextPath are defined in terms of servlets which we bypass completely.
 * we may need to amend this implementation
       *
 * @param request
 * @return
 */
      private final void buildPathInfo(final HttpServletRequest request) {
          fullPath = request.getContextPath() + (request.getPathInfo() ==  null ? "" : request.getPathInfo());

          // Strip the binding protocolBindingRoot off the front.
          if (protocolBindingRoot != null && protocolBindingRoot.length() > 0) {
              operationPath =  fullPath.substring(protocolBindingRoot.length());
          } else {
              operationPath =  fullPath;
          }
}
 

@SuppressWarnings("unchecked")
@Override
public void service(HttpServletRequest request,
                    HttpServletResponse response) throws ServletException, IOException {
    Object obj = request.getAttribute(ServletController.AUTH_SERVICE_LIST);
    boolean isAuthServiceList = false;
    if (obj != null) {
        isAuthServiceList = Boolean.valueOf(obj.toString());
    }
    if (isAuthServiceList) {
        String authServiceListRealm = (String)request.getAttribute(ServletController.AUTH_SERVICE_LIST_REALM);
        ServiceListJAASAuthenticator authenticator = new ServiceListJAASAuthenticator();
        authenticator.setRealm(authServiceListRealm);
        if (!authenticator.authenticate(request, response)) {
            return;
        }
        request.removeAttribute(ServletController.AUTH_SERVICE_LIST);
        request.removeAttribute(ServletController.AUTH_SERVICE_LIST_REALM);
    }
    AbstractDestination[] destinations = destinationRegistry.getSortedDestinations();
    if (request.getParameter("stylesheet") != null) {
        renderStyleSheet(request, response);
        return;
    }
    List<String> privateEndpoints;
    if (bus == null) {
        bus = BusFactory.getDefaultBus(false);
    }
    if (bus != null) {
        privateEndpoints = (List<String>)bus.getProperty("org.apache.cxf.private.endpoints");
    } else {
        privateEndpoints = new ArrayList<>();
    }

    AbstractDestination[] soapEndpoints = getSOAPEndpoints(destinations, privateEndpoints);
    AbstractDestination[] restEndpoints = getRestEndpoints(destinations, privateEndpoints);
    ServiceListWriter serviceListWriter;
    if ("false".equals(request.getParameter("formatted"))) {
        boolean renderWsdlList = "true".equals(request.getParameter("wsdlList"));
        serviceListWriter = new UnformattedServiceListWriter(renderWsdlList, bus);
    } else {
        String styleSheetPath;
        if (serviceListStyleSheet != null) {
            styleSheetPath = request.getContextPath() + "/" + serviceListStyleSheet;
        } else {
            styleSheetPath = "";
            String contextPath = request.getContextPath();
            if (contextPath != null) {
                styleSheetPath += contextPath;
            }
            String servletPath = request.getServletPath();
            if (servletPath != null) {
                styleSheetPath += servletPath;
            }
            String pathInfo = request.getPathInfo();
            if (pathInfo != null) {
                styleSheetPath += pathInfo;
            }

            if (!styleSheetPath.endsWith("/")) {
                styleSheetPath += "/";
            }
            styleSheetPath += "?stylesheet=1";
        }
        serviceListWriter =
            new FormattedServiceListWriter(styleSheetPath, title, showForeignContexts, bus);

    }
    response.setContentType(serviceListWriter.getContentType());
    Object basePath = request.getAttribute(Message.BASE_PATH);
    serviceListWriter.writeServiceList(response.getWriter(),
                                       basePath == null ? null : basePath.toString(),
                                       soapEndpoints, restEndpoints);
}
 

/**
 * 获取请求路径
 * /servlet/MyServlet/a/b
 *
 * @param request
 * @return
 */
public static String getRequestPath(HttpServletRequest request) {
    String servletPath = request.getServletPath(); // /servlet/MyServlet
    String pathInfo = request.getPathInfo();    // /a/b

    return (null != servletPath ? servletPath : "") + StringUtils.defaultIfEmpty(pathInfo, StringUtils.EMPTY);
}