Java 类javax.servlet.http.HttpServlet 实例源码

@Test
public void testExcludedResponseStatusCode() throws Exception {
    HttpServlet servlet = new HttpServlet() {
        private static final long serialVersionUID = 1L;

        @Override
        protected void service(HttpServletRequest request,
                HttpServletResponse response) throws ServletException,
                IOException {
            response.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
            response.addHeader("ETag", "W/\"1934-1269208821000\"");
            response.addDateHeader("Date", System.currentTimeMillis());
        }
    };

    validate(servlet, null, HttpServletResponse.SC_NOT_MODIFIED);
}

@Test
public void testSkipBecauseExpiresIsDefined() throws Exception {
    HttpServlet servlet = new HttpServlet() {
        private static final long serialVersionUID = 1L;

        @Override
        protected void service(HttpServletRequest request,
                HttpServletResponse response) throws ServletException,
                IOException {
            response.setContentType("text/xml; charset=utf-8");
            response.addDateHeader("Expires", System.currentTimeMillis());
            response.getWriter().print("Hello world");
        }
    };

    validate(servlet, null);
}

@Test
public void testExcludedResponseStatusCode() throws Exception {
    HttpServlet servlet = new HttpServlet() {
        private static final long serialVersionUID = 1L;

        @Override
        protected void service(HttpServletRequest request,
                HttpServletResponse response) throws ServletException,
                IOException {
            response.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
            response.addHeader("ETag", "W/\"1934-1269208821000\"");
            response.addDateHeader("Date", System.currentTimeMillis());
        }
    };

    validate(servlet, null, HttpServletResponse.SC_NOT_MODIFIED);
}

@Test
public void testSkipBecauseExpiresIsDefined() throws Exception {
    HttpServlet servlet = new HttpServlet() {
        private static final long serialVersionUID = 1L;

        @Override
        protected void service(HttpServletRequest request,
                HttpServletResponse response) throws ServletException,
                IOException {
            response.setContentType("text/xml; charset=utf-8");
            response.addDateHeader("Expires", System.currentTimeMillis());
            response.getWriter().print("Hello world");
        }
    };

    validate(servlet, null);
}

@Override
public void init(HttpServlet servlet) throws Exception {
    TimeZone.setDefault(TimeZone.getTimeZone("Asia/Shanghai"));
    ServletContext servletContext = servlet.getServletContext();
    String configFileName = servletContext.getInitParameter("configFileName");
    Properties properties = loadConfig(configFileName);
    MybatisManager.init(properties.getProperty("config_dir"), "mybatis-config.xml", new MariadbLog());
    HttpUtil.init("UTF-8", new HttpclientLog());
    ThreadmsgLog threadmsgLog = new ThreadmsgLog();
    AsyncThreadManager.init(100, 10, 3, 0, threadmsgLog);
    AsyncThreadManager.start();
    MsgManager.init(true, threadmsgLog);
    CommonConfig.init(properties);
    HOpCode.init();

    MsgOpCode.init();
    HttpManager.addFilter(new TokenHttpFilter());
    HttpManager.addHttpListener(new AppService());
    HttpManager.addHttpListener(new OrderRecordService());
    HttpManager.addHttpListener(new PayService());
    HttpManager.addHttpListener(new LoginService());
    MsgManager.addMsgListener(new NotifyService(10));
}

/**
 * Add an internal servlet in the server, specifying whether or not to
 * protect with Kerberos authentication.
 * Note: This method is to be used for adding servlets that facilitate
 * internal communication and not for user facing functionality. For
 +   * servlets added using this method, filters (except internal Kerberos
 * filters) are not enabled.
 *
 * @param name The name of the servlet (can be passed as null)
 * @param pathSpec The path spec for the servlet
 * @param clazz The servlet class
 * @param requireAuth Require Kerberos authenticate to access servlet
 */
public void addInternalServlet(String name, String pathSpec,
    Class<? extends HttpServlet> clazz, boolean requireAuth) {
  ServletHolder holder = new ServletHolder(clazz);
  if (name != null) {
    holder.setName(name);
  }
  webAppContext.addServlet(holder, pathSpec);

  if(requireAuth && UserGroupInformation.isSecurityEnabled()) {
     LOG.info("Adding Kerberos (SPNEGO) filter to " + name);
     ServletHandler handler = webAppContext.getServletHandler();
     FilterMapping fmap = new FilterMapping();
     fmap.setPathSpec(pathSpec);
     fmap.setFilterName(SPNEGO_FILTER);
     fmap.setDispatches(Handler.ALL);
     handler.addFilterMapping(fmap);
  }
}

@Override
public void init(HttpServlet servlet) throws Exception {
    TimeZone.setDefault(TimeZone.getTimeZone("Asia/Shanghai"));
    ServletContext servletContext = servlet.getServletContext();
    String configFileName = servletContext.getInitParameter("configFileName");
    Properties properties = loadConfig(configFileName);
    MybatisManager.init(properties.getProperty("config_dir"), "mybatis-config.xml", new MariadbLog());
    KeyLockManager.init(new UCenterKeyLockType().getkeyLockType(), 120000, 100, new KeylockLog());
    HOpCodeUCenter.init();
    CommonConfigUCenter.init();
    CommonConfigUCenter.UCENTER_URL = properties.getProperty("uCenterUrl");
    HttpManager.addFilter(new TokenHttpFilter());
    HttpManager.addHttpListener(new UserService());
    HttpManager.addHttpListener(new UserGroupService());
    HttpManager.addHttpListener(new TokenService());
}

/**
 * Test that a resource with empty content is also processed
 */
@Test
public void testEmptyContent() throws Exception {
    HttpServlet servlet = new HttpServlet() {
        private static final long serialVersionUID = 1L;

        @Override
        protected void service(HttpServletRequest request,
                HttpServletResponse response) throws ServletException,
                IOException {
            response.setContentType("text/plain");
            // no content is written in the response
        }
    };

    validate(servlet, Integer.valueOf(7 * 60));
}

@Test
public void testSkipBecauseCacheControlMaxAgeIsDefined() throws Exception {
    HttpServlet servlet = new HttpServlet() {
        private static final long serialVersionUID = 1L;

        @Override
        protected void service(HttpServletRequest request,
                HttpServletResponse response) throws ServletException,
                IOException {
            response.setContentType("text/xml; charset=utf-8");
            response.addHeader("Cache-Control", "private, max-age=232");
            response.getWriter().print("Hello world");
        }
    };

    validate(servlet, Integer.valueOf(232));
}

@Test
public void testUseContentTypeExpiresConfiguration() throws Exception {
    HttpServlet servlet = new HttpServlet() {
        private static final long serialVersionUID = 1L;

        @Override
        protected void service(HttpServletRequest request,
                HttpServletResponse response) throws ServletException,
                IOException {
            response.setContentType("text/xml; charset=utf-8");
            response.getWriter().print("Hello world");
        }
    };

    validate(servlet, Integer.valueOf(3 * 60));
}

@Test
public void testUseContentTypeWithoutCharsetExpiresConfiguration()
        throws Exception {
    HttpServlet servlet = new HttpServlet() {
        private static final long serialVersionUID = 1L;

        @Override
        protected void service(HttpServletRequest request,
                HttpServletResponse response) throws ServletException,
                IOException {
            response.setContentType("text/xml; charset=iso-8859-1");
            response.getWriter().print("Hello world");
        }
    };

    validate(servlet, Integer.valueOf(5 * 60));
}

@Test
public void testUseDefaultConfiguration1() throws Exception {
    HttpServlet servlet = new HttpServlet() {
        private static final long serialVersionUID = 1L;

        @Override
        protected void service(HttpServletRequest request,
                HttpServletResponse response) throws ServletException,
                IOException {
            response.setContentType("image/jpeg");
            response.getWriter().print("Hello world");
        }
    };

    validate(servlet, Integer.valueOf(1 * 60));
}

@Test
public void testUseDefaultConfiguration2() throws Exception {
    HttpServlet servlet = new HttpServlet() {
        private static final long serialVersionUID = 1L;

        @Override
        protected void service(HttpServletRequest request,
                HttpServletResponse response) throws ServletException,
                IOException {
            response.setContentType("image/jpeg");
            response.addHeader("Cache-Control", "private");

            response.getWriter().print("Hello world");
        }
    };

    validate(servlet, Integer.valueOf(1 * 60));
}

@Test
public void testUseMajorTypeExpiresConfiguration() throws Exception {
    HttpServlet servlet = new HttpServlet() {
        private static final long serialVersionUID = 1L;

        @Override
        protected void service(HttpServletRequest request,
                HttpServletResponse response) throws ServletException,
                IOException {
            response.setContentType("text/json; charset=iso-8859-1");
            response.getWriter().print("Hello world");
        }
    };

    validate(servlet, Integer.valueOf(7 * 60));
}

private void setupHeadersTest(Tomcat tomcat) {
    Context ctx = tomcat.addContext("", getTemporaryDirectory()
            .getAbsolutePath());
    Tomcat.addServlet(ctx, "servlet", new HttpServlet() {
        private static final long serialVersionUID = 1L;

        @Override
        public void service(ServletRequest req, ServletResponse res)
                throws ServletException, IOException {
            res.setContentType("text/plain; charset=ISO-8859-1");
            res.getWriter().write("OK");
        }
    });
    ctx.addServletMapping("/", "servlet");

    alv = new HeaderCountLogValve();
    tomcat.getHost().getPipeline().addValve(alv);
}

public void testContextParameters() throws Exception {
    WebXMLString wxs = new WebXMLString();
    wxs.addServlet( "/SimpleServlet", SimpleGetServlet.class );
    wxs.addContextParam( "icecream", "vanilla" );
    wxs.addContextParam( "cone", "waffle" );
    wxs.addContextParam( "topping", "" );

    ServletRunner sr = new ServletRunner( toInputStream( wxs.asText() ) );
    ServletUnitClient client = sr.newClient();
    assertEquals( "Context parameter 'icecream'", "vanilla", sr.getContextParameter( "icecream" ) );
    InvocationContext ic = client.newInvocation( "http://localhost/SimpleServlet" );

    javax.servlet.ServletContext sc = ((HttpServlet) ic.getServlet()).getServletContext();
    assertNotNull( "ServletContext should not be null", sc );
    assertEquals( "ServletContext.getInitParameter()", "vanilla", sc.getInitParameter( "icecream" ) );
    assertEquals( "init parameter: cone", "waffle", sc.getInitParameter( "cone" ) );
    assertEquals( "init parameter: topping", "", sc.getInitParameter( "topping" ) );
    assertNull( "ServletContext.getInitParameter() should be null", sc.getInitParameter( "shoesize" ) );

}

/**
 * Test that a resource with empty content is also processed
 */
@Test
public void testEmptyContent() throws Exception {
    HttpServlet servlet = new HttpServlet() {
        private static final long serialVersionUID = 1L;

        @Override
        protected void service(HttpServletRequest request,
                HttpServletResponse response) throws ServletException,
                IOException {
            response.setContentType("text/plain");
            // no content is written in the response
        }
    };

    validate(servlet, Integer.valueOf(7 * 60));
}

@Test
public void testSkipBecauseCacheControlMaxAgeIsDefined() throws Exception {
    HttpServlet servlet = new HttpServlet() {
        private static final long serialVersionUID = 1L;

        @Override
        protected void service(HttpServletRequest request,
                HttpServletResponse response) throws ServletException,
                IOException {
            response.setContentType("text/xml; charset=utf-8");
            response.addHeader("Cache-Control", "private, max-age=232");
            response.getWriter().print("Hello world");
        }
    };

    validate(servlet, Integer.valueOf(232));
}

@Test
public void testUseContentTypeExpiresConfiguration() throws Exception {
    HttpServlet servlet = new HttpServlet() {
        private static final long serialVersionUID = 1L;

        @Override
        protected void service(HttpServletRequest request,
                HttpServletResponse response) throws ServletException,
                IOException {
            response.setContentType("text/xml; charset=utf-8");
            response.getWriter().print("Hello world");
        }
    };

    validate(servlet, Integer.valueOf(3 * 60));
}

@Test
public void testUseContentTypeWithoutCharsetExpiresConfiguration()
        throws Exception {
    HttpServlet servlet = new HttpServlet() {
        private static final long serialVersionUID = 1L;

        @Override
        protected void service(HttpServletRequest request,
                HttpServletResponse response) throws ServletException,
                IOException {
            response.setContentType("text/xml; charset=iso-8859-1");
            response.getWriter().print("Hello world");
        }
    };

    validate(servlet, Integer.valueOf(5 * 60));
}

@Test
public void testUseDefaultConfiguration1() throws Exception {
    HttpServlet servlet = new HttpServlet() {
        private static final long serialVersionUID = 1L;

        @Override
        protected void service(HttpServletRequest request,
                HttpServletResponse response) throws ServletException,
                IOException {
            response.setContentType("image/jpeg");
            response.getWriter().print("Hello world");
        }
    };

    validate(servlet, Integer.valueOf(1 * 60));
}

@Test
public void testUseDefaultConfiguration2() throws Exception {
    HttpServlet servlet = new HttpServlet() {
        private static final long serialVersionUID = 1L;

        @Override
        protected void service(HttpServletRequest request,
                HttpServletResponse response) throws ServletException,
                IOException {
            response.setContentType("image/jpeg");
            response.addHeader("Cache-Control", "private");

            response.getWriter().print("Hello world");
        }
    };

    validate(servlet, Integer.valueOf(1 * 60));
}

@Test
public void testUseMajorTypeExpiresConfiguration() throws Exception {
    HttpServlet servlet = new HttpServlet() {
        private static final long serialVersionUID = 1L;

        @Override
        protected void service(HttpServletRequest request,
                HttpServletResponse response) throws ServletException,
                IOException {
            response.setContentType("text/json; charset=iso-8859-1");
            response.getWriter().print("Hello world");
        }
    };

    validate(servlet, Integer.valueOf(7 * 60));
}

private void setupHeadersTest(Tomcat tomcat) {
    Context ctx = tomcat.addContext("", getTemporaryDirectory()
            .getAbsolutePath());
    Tomcat.addServlet(ctx, "servlet", new HttpServlet() {
        private static final long serialVersionUID = 1L;

        @Override
        public void service(ServletRequest req, ServletResponse res)
                throws ServletException, IOException {
            res.setContentType("text/plain; charset=ISO-8859-1");
            res.getWriter().write("OK");
        }
    });
    ctx.addServletMapping("/", "servlet");

    alv = new HeaderCountLogValve();
    tomcat.getHost().getPipeline().addValve(alv);
}

/**
 * Add an internal servlet in the server, specifying whether or not to
 * protect with Kerberos authentication. 
 * Note: This method is to be used for adding servlets that facilitate
 * internal communication and not for user facing functionality. For
 +   * servlets added using this method, filters (except internal Kerberos
 * filters) are not enabled. 
 * 
 * @param name The name of the servlet (can be passed as null)
 * @param pathSpec The path spec for the servlet
 * @param clazz The servlet class
 * @param requireAuth Require Kerberos authenticate to access servlet
 */
public void addInternalServlet(String name, String pathSpec, 
    Class<? extends HttpServlet> clazz, boolean requireAuth) {
  ServletHolder holder = new ServletHolder(clazz);
  if (name != null) {
    holder.setName(name);
  }
  webAppContext.addServlet(holder, pathSpec);

  if(requireAuth && UserGroupInformation.isSecurityEnabled()) {
     LOG.info("Adding Kerberos (SPNEGO) filter to " + name);
     ServletHandler handler = webAppContext.getServletHandler();
     FilterMapping fmap = new FilterMapping();
     fmap.setPathSpec(pathSpec);
     fmap.setFilterName(SPNEGO_FILTER);
     fmap.setDispatches(Handler.ALL);
     handler.addFilterMapping(fmap);
  }
}

/**
 * Add an internal servlet in the server, specifying whether or not to
 * protect with Kerberos authentication.
 * Note: This method is to be used for adding servlets that facilitate
 * internal communication and not for user facing functionality. For
 +   * servlets added using this method, filters (except internal Kerberos
 * filters) are not enabled.
 *
 * @param name The name of the servlet (can be passed as null)
 * @param pathSpec The path spec for the servlet
 * @param clazz The servlet class
 * @param requireAuth Require Kerberos authenticate to access servlet
 */
public void addInternalServlet(String name, String pathSpec,
    Class<? extends HttpServlet> clazz, boolean requireAuth) {
  ServletHolder holder = new ServletHolder(clazz);
  if (name != null) {
    holder.setName(name);
  }
  webAppContext.addServlet(holder, pathSpec);

  if(requireAuth && UserGroupInformation.isSecurityEnabled()) {
     LOG.info("Adding Kerberos (SPNEGO) filter to " + name);
     ServletHandler handler = webAppContext.getServletHandler();
     FilterMapping fmap = new FilterMapping();
     fmap.setPathSpec(pathSpec);
     fmap.setFilterName(SPNEGO_FILTER);
     fmap.setDispatches(Handler.ALL);
     handler.addFilterMapping(fmap);
  }
}

@Test
public void test_filter_wrapper() throws IOException, ServletException {
    HttpServlet servlet = new HttpServlet() {
        @Override
        public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
            assertThat(req).isInstanceOf(SimpleSessionRequest.class);
            super.service(req, res);
        }
    };
    mockFilterChain = new MockFilterChain(servlet, filter);

    filter.doFilter(mockRequest, mockResponse, mockFilterChain);

    assertThat(mockRequest.getAttribute(SimpleSessionFilter.class.getName().concat(".VISITED")))
            .isEqualTo(Boolean.TRUE);
}

private Server createServer() {
    Server server = new Server();
    SelectChannelConnector connector = new SelectChannelConnector();
    connector.setPort(8384);
    server.addConnector(connector);

    ServletHandler handler = new ServletHandler();
    Servlet servlet = new HttpServlet() {
        private static final long serialVersionUID = 1L;

        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
            String path = req.getServletPath().substring(1);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
            }
            resp.getWriter().append(path);
        }

    };
    handler.addServletWithMapping(new ServletHolder(servlet), "/");
    server.setHandler(handler);
    return server;
}

/**
 * 请求委托
 * @param request
 * @param response
 * @param httpServlet
 */
public void entrust(HttpServletRequest request, HttpServletResponse response, HttpServlet httpServlet){
    method = request.getMethod();
    this.request = request;
    response.setCharacterEncoding(encode);

    //设置POST请求的字符编码
    if(method.equals("POST")){
        try {
            request.setCharacterEncoding(encode);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }

    //设置Content-Type
    response.setHeader("Content-Type", "text/html;charset=" + encode);

    execute(request, response, httpServlet);
}

/**
 * Add an internal servlet in the server, specifying whether or not to
 * protect with Kerberos authentication.
 * Note: This method is to be used for adding servlets that facilitate
 * internal communication and not for user facing functionality. For
 +   * servlets added using this method, filters (except internal Kerberos
 * filters) are not enabled.
 *
 * @param name The name of the servlet (can be passed as null)
 * @param pathSpec The path spec for the servlet
 * @param clazz The servlet class
 * @param requireAuth Require Kerberos authenticate to access servlet
 */
public void addInternalServlet(String name, String pathSpec,
    Class<? extends HttpServlet> clazz, boolean requireAuth) {
  ServletHolder holder = new ServletHolder(clazz);
  if (name != null) {
    holder.setName(name);
  }
  webAppContext.addServlet(holder, pathSpec);

  if(requireAuth && UserGroupInformation.isSecurityEnabled()) {
     LOG.info("Adding Kerberos (SPNEGO) filter to " + name);
     ServletHandler handler = webAppContext.getServletHandler();
     FilterMapping fmap = new FilterMapping();
     fmap.setPathSpec(pathSpec);
     fmap.setFilterName(SPNEGO_FILTER);
     fmap.setDispatches(Handler.ALL);
     handler.addFilterMapping(fmap);
  }
}

/**
 * Add an internal servlet in the server, specifying whether or not to
 * protect with Kerberos authentication.
 * Note: This method is to be used for adding servlets that facilitate
 * internal communication and not for user facing functionality. For
 +   * servlets added using this method, filters (except internal Kerberos
 * filters) are not enabled.
 *
 * @param name The name of the servlet (can be passed as null)
 * @param pathSpec The path spec for the servlet
 * @param clazz The servlet class
 * @param requireAuth Require Kerberos authenticate to access servlet
 */
public void addInternalServlet(String name, String pathSpec,
    Class<? extends HttpServlet> clazz, boolean requireAuth) {
  ServletHolder holder = new ServletHolder(clazz);
  if (name != null) {
    holder.setName(name);
  }
  webAppContext.addServlet(holder, pathSpec);

  if(requireAuth && UserGroupInformation.isSecurityEnabled()) {
     LOG.info("Adding Kerberos (SPNEGO) filter to " + name);
     ServletHandler handler = webAppContext.getServletHandler();
     FilterMapping fmap = new FilterMapping();
     fmap.setPathSpec(pathSpec);
     fmap.setFilterName(SPNEGO_FILTER);
     fmap.setDispatches(Handler.ALL);
     handler.addFilterMapping(fmap);
  }
}

@Override
public Module getChildServletModule() {
  return new ServletModule() {
    @Override
    protected void configureServlets() {
      filter(PATH).through(filter);
      serve(PATH).with(new HttpServlet() {
        @Override
        protected void service(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {

          mockServlet.service(req, resp);
          resp.setStatus(HttpServletResponse.SC_OK);
        }
      });
    }
  };
}

@Override
public Module getChildServletModule() {
  return new ServletModule() {
    @Override
    protected void configureServlets() {
      filter(PATH).through(filter);
      serve(PATH).with(new HttpServlet() {
        @Override
        protected void service(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {

          getMockServlet().service(req, resp);
          resp.setStatus(HttpServletResponse.SC_OK);
        }
      });
    }
  };
}

@Override
public void start() {
    try {
        servletContext.setContextPath("/");
        server.setHandler(servletContext);

        // configure servlets
        servlets.keySet().forEach(path -> {
            Class<? extends HttpServlet> servletClazz = servlets.get(path);
            HttpServlet servlet = ReflectionUtils.newInstance(
                    servletClazz, HttpServlet.class, new Object[]{ componentManager });
            LOG.info("Servlet instance created: path=" + path + ", servlet=" + servlet);

            servletContext.addServlet(new ServletHolder(servlet), path);
        });

        server.start();
    } catch (Exception e) {
        Throwables.propagate(e);
    } finally {
        stop();
    }
}

/** Sets the servlet that will receive all requests in this servlet context. */
public MockServletContext setServlet(Class<? extends HttpServlet> servletClass,
                       String servletName,
                       Map<String,String> initParams) {
    try {
        MockServletConfig config = new MockServletConfig();
        config.setServletName(servletName);
        config.setServletContext(this);
        if (initParams != null) config.addAllInitParameters(initParams);

        this.servlet = servletClass.newInstance();
        this.servlet.init(config);
        return this;
    }
    catch (Exception e) {
        throw new RuntimeException("Exception registering servlet with name " + servletName, e);
    }
}

/**
 * Returns an instance of AuthenticationManager subclass, based on the authentication.class
 * property in Openbravo.properties
 */
public final static AuthenticationManager getAuthenticationManager(HttpServlet s) {
  AuthenticationManager authManager;
  String authClass = OBPropertiesProvider.getInstance().getOpenbravoProperties()
      .getProperty("authentication.class", DEFAULT_AUTH_CLASS);
  if (authClass == null || authClass.equals("")) {
    // If not defined, load default
    authClass = "org.openbravo.authentication.basic.DefaultAuthenticationManager";
  }
  try {
    authManager = (AuthenticationManager) OBClassLoader.getInstance().loadClass(authClass)
        .newInstance();
    authManager.init(s);
  } catch (Exception e) {
    log4j
        .error("Defined authentication manager cannot be loaded. Verify the 'authentication.class' entry in Openbravo.properties");
    authManager = new DefaultAuthenticationManager(s);
    authManager.init(s);
  }
  return authManager;
}

/**
 * Add an internal servlet in the server, specifying whether or not to
 * protect with Kerberos authentication. 
 * Note: This method is to be used for adding servlets that facilitate
 * internal communication and not for user facing functionality. For
 +   * servlets added using this method, filters (except internal Kerberos
 * filters) are not enabled. 
 * 
 * @param name The name of the servlet (can be passed as null)
 * @param pathSpec The path spec for the servlet
 * @param clazz The servlet class
 * @param requireAuth Require Kerberos authenticate to access servlet
 */
public void addInternalServlet(String name, String pathSpec, 
    Class<? extends HttpServlet> clazz, boolean requireAuth) {
  ServletHolder holder = new ServletHolder(clazz);
  if (name != null) {
    holder.setName(name);
  }
  webAppContext.addServlet(holder, pathSpec);

  if(requireAuth && UserGroupInformation.isSecurityEnabled()) {
     LOG.info("Adding Kerberos (SPNEGO) filter to " + name);
     ServletHandler handler = webAppContext.getServletHandler();
     FilterMapping fmap = new FilterMapping();
     fmap.setPathSpec(pathSpec);
     fmap.setFilterName(SPNEGO_FILTER);
     fmap.setDispatches(Handler.ALL);
     handler.addFilterMapping(fmap);
  }
}

/**
 * Add an internal servlet in the server, specifying whether or not to
 * protect with Kerberos authentication.
 * Note: This method is to be used for adding servlets that facilitate
 * internal communication and not for user facing functionality. For
 +   * servlets added using this method, filters (except internal Kerberos
 * filters) are not enabled.
 *
 * @param name The name of the servlet (can be passed as null)
 * @param pathSpec The path spec for the servlet
 * @param clazz The servlet class
 * @param requireAuth Require Kerberos authenticate to access servlet
 */
public void addInternalServlet(String name, String pathSpec,
    Class<? extends HttpServlet> clazz, boolean requireAuth) {
  ServletHolder holder = new ServletHolder(clazz);
  if (name != null) {
    holder.setName(name);
  }
  webAppContext.addServlet(holder, pathSpec);

  if(requireAuth && UserGroupInformation.isSecurityEnabled()) {
     LOG.info("Adding Kerberos (SPNEGO) filter to " + name);
     ServletHandler handler = webAppContext.getServletHandler();
     FilterMapping fmap = new FilterMapping();
     fmap.setPathSpec(pathSpec);
     fmap.setFilterName(SPNEGO_FILTER);
     fmap.setDispatches(Handler.ALL);
     handler.addFilterMapping(fmap);
  }
}

public void apply(HttpServlet servlet, UserAwareRequest req, HttpServletResponse resp, UUID id)
        throws ServletException, IOException {

    Optional<Event> eventOpt = eventService.fetch(id);

    // Should never append but...
    if (!eventOpt.isPresent()) {
        redirect(req, resp, "/", tuple("error", "Événement non trouvé"));
        return;
    }

    Event event = eventOpt.get();

    Optional<Person> userOpt = req.getUser();
    // Logged user
    if (userOpt.isPresent()) {
        eventService.linkRegisteredPerson(event, userOpt.get());
        redirect(req, resp, "/events/" + event.getSlug());
        return;
    }

    redirect(req, resp, "/events/" + id + "/participants/add");

}

public void authentication(HttpServlet servlet, HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException {

    String event = req.getParameter("event");


    String email = req.getParameter("email");
    String password = req.getParameter("password");

    Optional<Person> login = personService.login(email, password);
    if (login.isPresent()) {
        HttpSession session = req.getSession();
        session.setAttribute("user", login.get());
        String last_url = Optional.ofNullable(session.getAttribute("last_url")).orElse("/").toString();
           if(event != null){
               redirect(req, resp, "/events/" + event + "/apply");
               return;
           }

        redirect(req, resp, last_url, tuple("info", "Identification réussie !"));
        return;
    }

    redirect(req, resp, "/login", tuple("error",
            "Impossible de vous identifier, merci de vérifier que les informations renseignées sont correctes."));
}