@Override
public void doFilter(
ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain)
throws IOException, ServletException {
HttpServletRequest req = (HttpServletRequest) servletRequest;
HttpServletResponse resp = (HttpServletResponse) servletResponse;
String uri = req.getRequestURI();
String path = uri.substring(0, uri.lastIndexOf("/") + 1);
String name = uri.substring(uri.lastIndexOf("/") + 1);
File testFile = new File("src/main/resources/tests" + path + "test-" + name);
if (req.getParameter("skiptest") == null && testFile.exists() && testFile.isFile()) {
Wrapper wrapper = new Wrapper(resp);
filterChain.doFilter(req, wrapper);
resp.flushBuffer();
if (wrapper.isWrapped()) {
String content = new String(wrapper.toByteArray(), "utf-8");
String test = IOUtils.toString(testFile.toURI().toURL(), "utf-8");
content = content.replace("</body>", test + "</body>");
resp.getOutputStream().print(content);
}
} else {
filterChain.doFilter(req, resp);
}
}
/**
* appends memento timegate link to all resources, that are accessed via GET on resource
* webservice
*
* @param servletRequest
* @param servletResponse
* @param filterChain
* @throws IOException
* @throws ServletException
*/
@Override
public void doFilter(
ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain)
throws IOException, ServletException {
if (servletRequest instanceof HttpServletRequest) {
HttpServletRequest request = (HttpServletRequest) servletRequest;
// memento is only for reading
if (request.getMethod().equals("GET") || request.getMethod().equals("HEAD")) {
HttpServletResponse response = (HttpServletResponse) servletResponse;
URL resource = getResourceURL(request);
// build timegate link
if (resource != null) {
response.addHeader(
"Link",
"<"
+ MementoUtils.timegateURI(resource.toString(), configurationService.getBaseUri())
+ ">; rel=\"timegate\","
+ "<"
+ MementoUtils.timemapURI(resource.toString(), configurationService.getBaseUri())
+ ">; rel=\"timemap\"");
}
filterChain.doFilter(servletRequest, response);
return;
}
}
filterChain.doFilter(servletRequest, servletResponse);
}
public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain)
throws ServletException, IOException {
HttpServletRequest request = (HttpServletRequest) req;
if (judgeIsMoblie(request)) {
chain.doFilter(req, resp);
return;
}
Object userId = request.getSession().getAttribute("userId");
String requestURI = request.getRequestURI();
if (isContinue(requestURI)) {
chain.doFilter(req, resp);
return;
}
if (null != userId) { // 只有登录验证成功（session还存在时），才继续
chain.doFilter(req, resp);
} else { // 否则 用户界面，自动弹出窗口提示用户输入登录账号，登录成功后可以继续使用本系统
HttpServletResponse response = (HttpServletResponse) resp;
String header = request.getHeader("x-requested-with");
if ("XMLHttpRequest".equals(header)) {
response.setStatus(401);
// response.setHeader("status", "401");
PrintWriter writer = response.getWriter();
writer.print("请重新登录");
writer.flush();
// Map<String, Object> map = new HashMap<String, Object>();
// W.writeJsonObject(map);
} else {
chain.doFilter(req, resp);
}
}
}
@Override
public void doFilter(
ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain)
throws IOException, ServletException {
if (servletRequest instanceof HttpServletRequest) {
CachedServletRequest cachedServletRequest =
new CachedServletRequest((HttpServletRequest) servletRequest);
filterChain.doFilter(cachedServletRequest, servletResponse);
} else {
filterChain.doFilter(servletRequest, servletResponse);
}
}
public static void main(String[] args) {
Request request = new Request();
request.setStrRequest("Request before interceptor");
Response response = new Response();
response.setStrResponse("Response before interceptor");
FilterChain filterChain = new FilterChain();
filterChain.addFilter(new HTMLTagFilter()).addFilter(new SpecialCharacterFilter());
filterChain.doFilter(request, response, filterChain);
System.out.println(request.getStrRequest());
System.out.println(response.getStrResponse());
}
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {
HttpServletRequest req = (HttpServletRequest) request;
if (req.getRequestURI().equals(req.getContextPath() + "/")) {
if (needsToCreateFirstUser()) {
((HttpServletResponse) response).sendRedirect("securityRealm/firstUser");
} else { // the first user already created. the role of this filter is over.
PluginServletFilter.removeFilter(this);
chain.doFilter(request, response);
}
} else chain.doFilter(request, response);
}
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {
HttpServletRequest syntheticRequest = new SyntheticRequest((HttpServletRequest) request);
HttpServletResponse syntheticResponse = new SyntheticResponse((HttpServletResponse) response);
HttpServletRequest syntheticRequest2 = new SyntheticRequest((HttpServletRequest) request);
HttpServletResponse syntheticResponse2 = new SyntheticResponse((HttpServletResponse) response);
chain.doFilter(syntheticRequest, syntheticResponse);
chain.doFilter(syntheticRequest2, syntheticResponse2);
}
public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain)
throws ServletException, IOException {
HttpServletRequest request = (HttpServletRequest) req;
HttpServletResponse response = (HttpServletResponse) resp;
HttpSession session = request.getSession(false);
AuthUserEntity user = (session != null) ? (AuthUserEntity) session.getAttribute("user") : null;
if (user != null && (user.getIsSuperuser() == 1 || user.getIsStaff() == 1)) {
chain.doFilter(request, resp);
} else {
response.sendRedirect(request.getContextPath() + "/login");
}
chain.doFilter(req, resp);
}
void redirectToPrimarilyRequestedUrl(
FilterChain chain,
HttpServletRequest httpRequest,
HttpServletResponse httpResponse,
ServiceAccess serviceAccess,
AuthorizationRequestData rdo)
throws IOException, ServletException {
String forwardUrl =
(String) httpRequest.getSession().getAttribute(Constants.SESS_ATTR_FORWARD_URL);
if (BesServletRequestReader.onlyServiceLogin(httpRequest.getSession())) {
if (forwardUrl == null) {
forwardUrl = Constants.SERVICE_BASE_URI + "/" + rdo.getSubscriptionKey() + "/";
}
JSFUtils.sendRedirect(httpResponse, httpRequest.getContextPath() + forwardUrl);
return;
}
if (ADMStringUtils.isBlank(forwardUrl) || forwardUrl.startsWith(MenuBean.LINK_DEFAULT)) {
forwardUrl = getDefaultUrl(serviceAccess, rdo, httpRequest);
}
if ((ADMStringUtils.isBlank(forwardUrl) || rdo.getRelativePath().startsWith(forwardUrl))
&& !rdo.isMarketplaceLoginPage()) {
chain.doFilter(httpRequest, httpResponse);
} else {
JSFUtils.sendRedirect(httpResponse, httpRequest.getContextPath() + forwardUrl);
}
}
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {
if (backupService == null) {
SpringBeanAutowiringSupport.processInjectionBasedOnCurrentContext(this);
}
String url = ((HttpServletRequest) request).getRequestURI();
if (isBackupFinishJsonUrl(url)) {
((HttpServletResponse) response).setHeader("Cache-Control", "private, max-age=0, no-cache");
((HttpServletResponse) response).setDateHeader("Expires", 0);
generateResponseForIsBackupFinishedAPI(response);
return;
}
if (backupService.isBackingUp()) {
((HttpServletResponse) response).setHeader("Cache-Control", "private, max-age=0, no-cache");
((HttpServletResponse) response).setDateHeader("Expires", 0);
if (isAPIUrl(url) && !isMessagesJson(url)) {
generateAPIResponse(request, response);
} else {
generateHTMLResponse(response);
}
} else {
chain.doFilter(request, response);
}
}
@Override
public void doFilter(
ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain)
throws IOException, ServletException {
System.out.println("Filter was called");
filterChain.doFilter(servletRequest, servletResponse);
}
@Override
public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain)
throws IOException, ServletException {
req.setCharacterEncoding("UTF-8");
resp.setCharacterEncoding("UTF-8");
chain.doFilter(req, resp);
}
public void doFilter(
final ServletRequest request, final ServletResponse response, FilterChain chain)
throws IOException, ServletException {
GenericResponseWrapper wrapper = new GenericResponseWrapper((HttpServletResponse) response);
chain.doFilter(request, wrapper);
}
/**
* Enforces the content-type to be application/octet-stream for POST and PUT requests.
*
* @param request servlet request.
* @param response servlet response.
* @param chain filter chain.
* @throws IOException thrown if an IO error occurrs.
* @throws ServletException thrown if a servet error occurrs.
*/
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {
boolean contentTypeOK = true;
HttpServletRequest httpReq = (HttpServletRequest) request;
HttpServletResponse httpRes = (HttpServletResponse) response;
String method = httpReq.getMethod();
if (method.equals("PUT") || method.equals("POST")) {
String op = httpReq.getParameter(HttpFSFileSystem.OP_PARAM);
if (op != null && UPLOAD_OPERATIONS.contains(op.toUpperCase())) {
if ("true"
.equalsIgnoreCase(httpReq.getParameter(HttpFSParametersProvider.DataParam.NAME))) {
String contentType = httpReq.getContentType();
contentTypeOK = HttpFSFileSystem.UPLOAD_CONTENT_TYPE.equalsIgnoreCase(contentType);
}
}
}
if (contentTypeOK) {
chain.doFilter(httpReq, httpRes);
} else {
httpRes.sendError(
HttpServletResponse.SC_BAD_REQUEST,
"Data upload requests must have content-type set to '"
+ HttpFSFileSystem.UPLOAD_CONTENT_TYPE
+ "'");
}
}
/** Ssets the locale context-wide based on a call to {@link JiveGlobals#getLocale()}. */
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {
final String pathInfo = ((HttpServletRequest) request).getPathInfo();
if (pathInfo == null) {
// Note, putting the locale in the application at this point is a little overkill
// (ie, every user who hits this filter will do this). Eventually, it might make
// sense to just set the locale in the user's session and if that's done we might
// want to honor a preference to get the user's locale based on request headers.
// For now, this is just a convenient place to set the locale globally.
Config.set(context, Config.FMT_LOCALE, JiveGlobals.getLocale());
} else {
try {
String[] parts = pathInfo.split("/");
String pluginName = parts[1];
ResourceBundle bundle = LocaleUtils.getPluginResourceBundle(pluginName);
LocalizationContext ctx = new LocalizationContext(bundle, JiveGlobals.getLocale());
Config.set(request, Config.FMT_LOCALIZATION_CONTEXT, ctx);
} catch (Exception e) {
// Note, putting the locale in the application at this point is a little overkill
// (ie, every user who hits this filter will do this). Eventually, it might make
// sense to just set the locale in the user's session and if that's done we might
// want to honor a preference to get the user's locale based on request headers.
// For now, this is just a convenient place to set the locale globally.
Config.set(context, Config.FMT_LOCALE, JiveGlobals.getLocale());
}
}
// Move along:
chain.doFilter(request, response);
}
/* (non-Javadoc)
* @see javax.servlet.Filter#doFilter(javax.servlet.ServletRequest, javax.servlet.ServletResponse, javax.servlet.FilterChain)
*/
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {
ServletRequest req = getRequest(request);
ServletResponse resp = getResponse(request, response);
request.setAttribute(PROCESSED_ATTR, Boolean.TRUE);
chain.doFilter(req, resp);
if (resp instanceof CompressedHttpServletResponseWrapper) {
CompressedHttpServletResponseWrapper compressedResponseWrapper =
(CompressedHttpServletResponseWrapper) resp;
try {
compressedResponseWrapper.close(); // so that stream is finished and closed.
} catch (IOException ex) {
LOGGER.error("Response was already closed: ", ex.toString());
}
if (compressedResponseWrapper.isCompressed()) {
req.setAttribute(COMPRESSED_ATTR, Boolean.TRUE);
}
}
}
public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain)
throws ServletException, IOException {
String contentType = req.getContentType();
if (contentType != null && contentType.startsWith(FILTERABLE_CONTENT_TYPE))
req.setCharacterEncoding(encoding);
chain.doFilter(req, resp);
}
@Override
public void doFilter(
ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain)
throws IOException, ServletException {
ServletRequest requestWrapper = null;
ServletResponse responseWrapper = null;
if (servletRequest instanceof HttpServletRequest) {
HttpServletRequest temp = (HttpServletRequest) servletRequest;
// 只对POST方法进行包装
if (temp.getMethod().toUpperCase().equals("POST")) {
requestWrapper = new CustomHttpServletRequestWrapper((HttpServletRequest) servletRequest);
}
}
if (servletResponse instanceof HttpServletResponse) {
responseWrapper = new CustomHttpServletResponseWrapper((HttpServletResponse) servletResponse);
// responseWrapper = new ContentCachingResponseWrapper((HttpServletResponse)
// servletResponse);
}
if (requestWrapper != null) {
servletRequest = requestWrapper;
}
if (responseWrapper != null) {
servletResponse = responseWrapper;
}
filterChain.doFilter(servletRequest, servletResponse);
}
@Override
public void doFilter(
@Nonnull ServletRequest request,
@Nonnull ServletResponse response,
@Nonnull FilterChain chain)
throws IOException, ServletException {
final StopWatch stopWatch = new StopWatch();
request.setAttribute(CURRENT_REQUEST_STOP_WATCH_ATTRIBUTE_NAME, stopWatch);
final ScopeMapping globalMapping = _patternToMapping.get(null);
final ScopeMapping specificMapping =
request instanceof HttpServletRequest
? getMappingFor(((HttpServletRequest) request).getRequestURI())
: null;
try {
chain.doFilter(request, response);
} finally {
request.removeAttribute(CURRENT_REQUEST_STOP_WATCH_ATTRIBUTE_NAME);
final Duration duration = stopWatch.getCurrentDuration();
final ServletHealthInterceptor interceptor = _interceptor;
if (interceptor == null
|| interceptor.isRecordAllowed(request, globalMapping, specificMapping)) {
globalMapping.record(null, duration);
if (specificMapping != null) {
final String targetName =
interceptor != null
? interceptor.getSpecificTargetName(request, specificMapping)
: null;
specificMapping.record(targetName, duration);
}
}
}
}
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {
HttpServletRequest httpServletRequest = (HttpServletRequest) request;
System.out.println("My filter1===" + httpServletRequest.getRequestURI());
chain.doFilter(request, response);
}
@SuppressWarnings("squid:S00112")
@Override
public void doFilter(
ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain)
throws IOException, ServletException {
// create response wrapper to capture the output stream from further down the filter chain
ResponseWrapper respWrap = new ResponseWrapper((HttpServletResponse) servletResponse);
filterChain.doFilter(servletRequest, respWrap);
HttpServletRequest req = (HttpServletRequest) servletRequest;
// Print out info from request & response wrapper
LOG.info("URI: {}", req.getRequestURI());
LOG.info("Status: {}", respWrap.getStatus());
LOG.info("resp Header 'Content-Type: {}", respWrap.getHeader("Content-Type"));
String content = respWrap.getContent();
LOG.info("Content Body: '{}'", content);
// verify that the content is not empty. This fails in repose but works in tomcat
if (content.isEmpty()) {
throw new RuntimeException("Content is empty");
}
// writer content to the actual servletResponse & append additional content
servletResponse
.getWriter()
.write(
content
+ "<extra> Added by TestFilter, should also see the rest of the content </extra>");
servletResponse.getWriter().flush();
}
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {
LOGGER.info("Cors Filter Entering");
final HttpServletResponse httpServletResponse = (HttpServletResponse) response;
final HttpServletRequest httpServletRequest = (HttpServletRequest) request;
String originHeader = httpServletRequest.getHeader("Origin");
if (httpServletRequest.getMethod().equals(HttpMethod.OPTIONS.name())) {
if (OriginsHelper.isValid(originHeader)) {
LOGGER.info("Adding Header Allow Origin: " + originHeader);
httpServletResponse.addHeader("Access-Control-Allow-Origin", originHeader);
}
httpServletResponse.setHeader(
"Access-Control-Allow-Methods", "POST, PUT, GET, OPTIONS, DELETE");
httpServletResponse.setHeader(
"Access-Control-Allow-Headers", "Content-Type, Authorization, Accept");
httpServletResponse.setHeader("Access-Control-Max-Age", "3600");
LOGGER.info("Return OK status for OPTIONS method requests");
httpServletResponse.setStatus(HttpServletResponse.SC_OK);
} else {
LOGGER.info("Continue filter processing");
chain.doFilter(request, response);
}
}
public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)
throws IOException, ServletException {
if (req instanceof HttpServletRequest) {
HttpServletRequest request = (HttpServletRequest) req;
HttpServletResponse response = (HttpServletResponse) res;
String ae = request.getHeader("accept-encoding");
if (ae != null && ae.indexOf("gzip") != -1) {
log.debug("GZIP supported, compressing.");
GZIPResponseWrapper wrappedResponse = new GZIPResponseWrapper(response);
chain.doFilter(req, wrappedResponse);
wrappedResponse.finishResponse();
return;
}
chain.doFilter(req, res);
}
}
private void processEncrypt(final ServletRequest servletRequest ,final HttpServletRequest httpRequest,final ServletResponse servletResponse,
final FilterChain filterChain)throws IOException, ServletException{
InputStream inputStream = servletRequest.getInputStream();
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
byte buf[] = new byte[1024];
int letti=-1;
while ((letti = inputStream.read(buf)) > 0){
byteArrayOutputStream.write(buf, 0, letti);
}
final BufferedRequestWrapper bufferedRequest = new BufferedRequestWrapper(httpRequest,doEncrypt(byteArrayOutputStream));
final HttpServletResponse response = (HttpServletResponse) servletResponse;
final ByteArrayPrintWriter pw = new ByteArrayPrintWriter();
HttpServletResponse wrappedResp = new HttpServletResponseWrapper(response) {
public PrintWriter getWriter() {
return pw.getWriter();
}
public ServletOutputStream getOutputStream() {
return pw.getStream();
}
};
filterChain.doFilter(bufferedRequest, wrappedResp);
}
/**
* realization of filter
*
* @param request
* @param response
* @param chain
*/
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws ServletException, IOException {
request.setCharacterEncoding(code);
response.setCharacterEncoding(code);
chain.doFilter(request, response);
}
@Override
public void doFilter(Request request, Response response, FilterChain chain) {
// TODO Auto-generated method stub
request.requestStr = request.requestStr.replace('<', '[').replace('>', ']');
chain.doFilter(request, response, chain);
response.responseStr += "HTMLFilter\t";
}
@Override
public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)
throws IOException, ServletException {
Boolean mob = (Boolean) ((HttpServletRequest) req).getSession().getAttribute("isMobile");
if (mob != null && !mob) {
chain.doFilter(req, res);
return;
}
String userAgent = ((HttpServletRequest) req).getHeader("User-Agent");
if (userAgent != null) {
boolean isMobile = userAgent.contains("Android") || userAgent.contains("iPhone");
((HttpServletRequest) req).getSession().setAttribute("isMobile", new Boolean(isMobile));
if (isMobile) {
String url = ((HttpServletRequest) req).getRequestURL().toString();
String params = "";
if (url.contains("Publication")) {
String id = url.substring(url.lastIndexOf("/") + 1);
PublicationDetail pub = getPubBm().getDetail(new PublicationPK(id));
String appId = pub.getInstanceId();
params =
"?shortcutContentType=Publication&shortcutContentId="
+ id
+ "&shortcutAppId="
+ appId;
} else if (url.contains("Media")) {
String id = url.substring(url.lastIndexOf("/") + 1);
Media media = getGalleryService().getMedia(new MediaPK(id));
String appId = media.getInstanceId();
params = "?shortcutContentType=Media&shortcutContentId=" + id + "&shortcutAppId=" + appId;
} else {
chain.doFilter(req, res);
return;
}
((HttpServletResponse) res).sendRedirect("/silverpeas/spmobile/" + params);
return;
} else {
chain.doFilter(req, res);
return;
}
} else {
chain.doFilter(req, res);
return;
}
}
/** @inheritDoc */
public FilterResult checkEligibility(Person person, FilterChain filterChain) throws Exception {
if (!Collections.disjoint(person.getGroupMemberships(), eligibleGroupMemberships)) {
return new FilterResult(true, "has membership in eligible group");
} else {
return filterChain.checkEligibility(person);
}
}
public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain)
throws ServletException, IOException {
try {
chain.doFilter(req, resp);
} finally {
JdoUtil.closePm();
}
}
public void doFilter(
ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain)
throws IOException, ServletException {
if (encoding != null) {
servletRequest.setCharacterEncoding(encoding);
}
filterChain.doFilter(servletRequest, servletResponse);
}
