• Home
• com.doublechaintech
• caf-web-isolator
• 1.0.0
• source code
• ServletResultRenderer.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.terapico.caf.ServletResultRenderer Maven / Gradle / Ivy

package com.terapico.caf;

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.terapico.uccaf.CafEntity;
import org.springframework.beans.factory.BeanCreationException;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.net.MalformedURLException;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

@SuppressWarnings("rawtypes")
public class ServletResultRenderer {

  public static final String X_HEADES =
      "X-Class, X-Redirect, X-Env-Type, X-Env-Name, X-Action, authorization, x-navigation-method";

  protected void renderMimeObjectResult(
      HttpServlet servlet,
      InvocationResult result,
      HttpServletRequest request,
      HttpServletResponse response)
      throws IOException {

    Object actualResult = result.getActualResult();
    if (!(actualResult instanceof BlobObject)) {
      throw new IllegalArgumentException("The return object is not a blob");
    }
    BlobObject blob = (BlobObject) actualResult;
    response.addHeader("X-Env-Type", result.getEnvType());
    response.addHeader("X-Env-Name", result.getEnvName());
    response.setCharacterEncoding(null);
    response.setContentType(blob.getMimeType());
    blob.getHeaders().forEach((k, v) -> response.setHeader(k, v));
    response.getOutputStream().write(blob.getData());
  }

  public void render(
      HttpServlet servlet,
      HttpServletRequest request,
      HttpServletResponse response,
      InvocationResult result)
      throws ServletException, IOException {
    // When integrate with WeiXin, some special request has accept:*/* , and must
    // render as plainText
    // so decide render way by result.isRenderByXXX first
    if (result.getActualResult() instanceof BlobObject) {
      renderMimeObjectResult(servlet, result, request, response);
      return;
    }
    if (result.isAssignedRenderingWay()) {
      if (result.isRenderAsHtml()) {
        renderHTMLPage(servlet, result, request, response);
        return;
      }
      if (result.isRenderAsJavaScript()) {
        renderJavascript(servlet, result, request, response);
        return;
      }
      if (result.isRenderAsJSON()) {
        renderJson(result, request, response);
        return;
      }
      // otherwise, use default render-decide procedure
    }

    if (this.isRequestForHTML(request)) {
      renderHTMLPage(servlet, result, request, response);
      return;
    }
    if (this.isRequestForJavascript(request)) {
      renderJavascript(servlet, result, request, response);
      return;
    }

    if (ReflectionTool.isPrimaryType(result.getActualResult().getClass())) {
      renderAsString(result, request, response);
      return;
    }
    // Otherwise use JSON as the default return format
    renderJson(result, request, response);
    return;
  }

  private void renderAsString(
      InvocationResult result, HttpServletRequest request, HttpServletResponse response)
      throws IOException {

    response.setContentType("text/plain");

    String renderClass = result.getActualResult().getClass().getName();
    if (result.getResponseHeader() != null && result.getResponseHeader().containsKey("X-Class")) {
      renderClass = result.getResponseHeader().get("X-Class");
    }
    byte[] value = result.getActualResult().toString().getBytes();
    int length = value.length;
    fillOrigin(result, request, response);
    response.addHeader("X-Class", renderClass);
    response.addHeader("X-Env-Type", result.getEnvType());
    response.addHeader("X-Env-Name", result.getEnvName());
    response.addHeader("Content-Length", Long.valueOf(length).toString());
    response.addHeader("Access-Control-Expose-Headers", X_HEADES);

    response.getOutputStream().write(value);
    ;
  }

  protected String getHost(HttpServletRequest request) {
    if (!isBehideProxy(request)) {
      return request.getHeader("host");
    }
    return request.getHeader("X-Forwarded-Host"); // include hostname and port
  }

  protected String getPort(HttpServletRequest request) {
    if (!isBehideProxy(request)) {
      return String.valueOf(request.getServerPort());
    }
    return request.getHeader("X-Forwarded-Port");
  }

  protected String calcBaseURL(HttpServletRequest request) {
    String port = getPort(request);
    String host = getHost(request);
    if (port == null
        || port.isEmpty()
        || port.equalsIgnoreCase("null")
        || port.equals("80")
        || port.equals("443")) {
      return "//" + host + request.getContextPath();
    }
    if (host.indexOf(':') > 0) {
      return "//" + host + request.getContextPath();
    }
    return "//" + host + ":" + port + request.getContextPath();
  }

  private boolean isBehideProxy(HttpServletRequest request) {

    if (request.getHeader("X-Forwarded-For") != null) {
      return true;
    }
    if (request.getHeader("X-Forwarded-Host") != null) {
      return true;
    }
    if (request.getHeader("X-Forwarded-Server") != null) {
      return true;
    }

    return false;
  }

  protected boolean isRequestForJson(HttpServletRequest request) {

    return hasHeaderWithValue(request, "Accept", "application/json");
  }

  protected boolean isRequestForHTML(HttpServletRequest request) {

    return hasHeaderWithValue(request, "Accept", "text/html");
  }

  protected boolean isRequestForJavascript(HttpServletRequest request) {

    return hasHeaderWithValue(request, "Accept", "application/javascript");
  }

  protected void assertNotEmptyStringArgument(
      String methodName, String parameterName, String paramterValue) {
    if (paramterValue == null) {
      throw new IllegalArgumentException(
          "Method '" + methodName + "': parameter: '" + parameterName + "' should not be null.");
    }
    if (paramterValue.isEmpty()) {
      throw new IllegalArgumentException(
          "Method '"
              + methodName
              + "': parameter: '"
              + parameterName
              + "' should not be emptry string.");
    }
  }

  protected boolean hasHeaderWithValue(HttpServletRequest request, String header, String value) {
    final String methodName =
        "hasHeaderWithValue(HttpServletRequest request, String header, String value)";

    assertNotEmptyStringArgument(methodName, "header", header);
    assertNotEmptyStringArgument(methodName, "value", value);

    String accept = request.getHeader(header);
    if (accept == null) {
      return false;
    }
    if (accept.isEmpty()) {
      return false;
    }
    if (accept.contains(value)) {
      return true;
    }
    return false;
  }

  private ObjectMapper objectMapper = null;

  protected ObjectMapper getObjectMapper() {
    //// objectMapper = null;
    // if(objectMapper == null){
    // objectMapper = new ObjectMapper();
    // return objectMapper;
    // //DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
    // //objectMapper.setDateFormat(df);
    // }
    //
    // return objectMapper.copy();
    ObjectMapper mapper = new ObjectMapper();
    mapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
    mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    mapper.setSerializationInclusion(JsonInclude.Include.NON_EMPTY);
    return mapper;
  }

  protected void fillOrigin(
      InvocationResult result, HttpServletRequest request, HttpServletResponse response) {
    String origin = request.getHeader("Origin");
    if (origin == null) {
      return;
    }
    response.addHeader("Access-Control-Allow-Origin", origin);
    response.addHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
    // Access-Control-Expose-Headers
    response.addHeader(
        "Access-Control-Expose-Headers",
        "Set-Cookie, X-Redirect, X-Env-Type, X-Env-Name, X-Action, authorization");
    response.addHeader(
        "Access-Control-Allow-Headers",
        "Set-Cookie, X-Redirect, X-Env-Type, X-Env-Name, X-Action, authorization");
    response.addHeader("Access-Control-Allow-Credentials", "true");
  }

  protected String renderLogResult(Object value) {
    if (ReflectionTool.isPrimaryType(value.getClass())) {
      return value.toString();
    }
    return "