Example usage for javax.servlet.http HttpServlet init

List of usage examples for javax.servlet.http HttpServlet init

Introduction

In this page you can find the example usage for javax.servlet.http HttpServlet init.

Prototype

public void init() throws ServletException 

Source Link

Document

A convenience method which can be overridden so that there's no need to call super.init(config).

Usage

From source file:org.soybeanMilk.test.unit.web.TestDispatchServlet.java

protected void initServlet(HttpServlet servlet) {
    try {/*from   ww w. j a v  a2  s .  c o m*/
        servlet.init();
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

From source file:com.web.server.WebServer.java

/**
 * This method obtains the content executor which executes the executor services
 * @param deployDirectory//from w  w w . ja v  a 2s .  c  om
 * @param resource
 * @param httpHeaderClient
 * @param serverdigester
 * @return byte[]
 */
public byte[] ObtainContentExecutor(String deployDirectory, String resource, HttpHeaderClient httpHeaderClient,
        Digester serverdigester, Hashtable urlClassLoaderMap, ConcurrentHashMap servletMapping,
        com.web.server.HttpSessionServer session) {
    //System.out.println("In content Executor");
    String[] resourcepath = resource.split("/");
    //System.out.println("createDigester1");
    Method method = null;
    //System.out.println("createDigester2");
    ////System.out.println();
    com.web.server.Executors serverconfig;
    if (resourcepath.length > 1) {
        ////System.out.println(resource);

        try {
            ClassLoader oldCL = null;
            String urlresource = ObtainUrlFromResource(resourcepath);
            try {
                //System.out.println(servletMapping);
                //System.out.println(deployDirectory+"/"+resourcepath[1]);
                HttpSessionServer httpSession;
                logger.info(deployDirectory + "/" + resourcepath[1] + " "
                        + servletMapping.get(deployDirectory + "/" + resourcepath[1]));
                if (servletMapping.get(deployDirectory + "/" + resourcepath[1]) != null) {
                    WebAppConfig webAppConfig = (WebAppConfig) servletMapping
                            .get(deployDirectory + "/" + resourcepath[1]);
                    webAppConfig = webAppConfig.clone();
                    webAppConfig.setWebApplicationAbsolutePath(deployDirectory + "/" + resourcepath[1]);
                    WebClassLoader customClassLoader = null;
                    Class customClass = null;
                    customClassLoader = (WebClassLoader) urlClassLoaderMap
                            .get(deployDirectory + "/" + resourcepath[1]);
                    oldCL = Thread.currentThread().getContextClassLoader();
                    Thread.currentThread().setContextClassLoader(customClassLoader);
                    ConcurrentHashMap servletMappingsURL = webAppConfig.getServletMappingURL();
                    Enumeration urlPattern = servletMappingsURL.keys();
                    while (urlPattern.hasMoreElements()) {
                        String pattern = (String) urlPattern.nextElement();
                        Pattern r = Pattern.compile(pattern.replace("*", "(.*)"));
                        Matcher m = r.matcher(urlresource);
                        if (m.find()) {
                            urlresource = pattern;
                            break;
                        }
                    }
                    LinkedHashMap<String, Vector<FilterMapping>> filterMappings = webAppConfig
                            .getFilterMappingURL();
                    Set<String> filterMappingKeys = filterMappings.keySet();
                    Iterator<String> filterMappingRoller = filterMappingKeys.iterator();
                    Vector<FilterMapping> filterMapping = null;
                    while (filterMappingRoller.hasNext()) {
                        String pattern = (String) filterMappingRoller.next();
                        Pattern r = Pattern.compile(pattern.replace("*", "(.*)"));
                        Matcher m = r.matcher(urlresource);
                        if (m.find()) {
                            filterMapping = filterMappings.get(pattern);
                            break;
                        }
                    }
                    if (servletMappingsURL.get(urlresource) != null) {
                        ServletMapping servletMappings = (ServletMapping) servletMappingsURL.get(urlresource);
                        ConcurrentHashMap servlets = webAppConfig.getServlets();
                        Servlets servlet = (Servlets) servlets.get(servletMappings.getServletName());

                        HttpServlet httpServlet = null;
                        System.out.println("Session " + session);
                        if (session.getAttribute("SERVLETNAME:" + deployDirectory + "/" + resourcepath[1]
                                + servletMappings.getServletName()) != null) {
                            httpServlet = (HttpServlet) session.getAttribute("SERVLETNAME:" + deployDirectory
                                    + "/" + resourcepath[1] + servletMappings.getServletName());
                            httpServlet.init();
                        } else {
                            Class servletClass = customClassLoader.loadClass(servlet.getServletClass());
                            httpServlet = (HttpServlet) servletClass.newInstance();
                            httpServlet.init(new WebServletConfig(servlet.getServletName().trim(), webAppConfig,
                                    customClassLoader));
                            httpServlet.init();
                            session.setAttribute("SERVLETNAME:" + deployDirectory + "/" + resourcepath[1]
                                    + servletMappings.getServletName(), httpServlet);
                            //ClassLoaderUtil.closeClassLoader(customClassLoader);
                        }
                        if (httpHeaderClient.getHttpMethod().trim().toUpperCase().equals("GET")
                                || httpHeaderClient.getHttpMethod().trim().toUpperCase().equals("POST")) {
                            Response response = new Response(httpHeaderClient);
                            StringBuffer servletPath = new StringBuffer();
                            if (resourcepath.length > 1) {
                                int pathcount = 0;
                                for (String servPath : resourcepath) {
                                    if (pathcount > 1) {
                                        servletPath.append("/");
                                        servletPath.append(servPath);
                                    }
                                    pathcount++;
                                }
                            }
                            String servletpath = servletPath.toString();
                            if (servletpath.length() == 0)
                                servletpath = "/";
                            Request request = new Request(httpHeaderClient, session, servletpath,
                                    customClassLoader);
                            if (filterMapping != null) {
                                WebFilterChain webFilterChain = new WebFilterChain(httpServlet, webAppConfig,
                                        filterMapping, customClassLoader);
                                webFilterChain.doFilter(request, response);
                            } else {
                                httpServlet.service(request, response);
                            }

                            //System.out.println("RESPONSE="+new String(response.getResponse()));
                            //httpServlet.destroy();
                            response.flushBuffer();
                            return response.getResponse();
                        }

                        //httpServlet.destroy();
                    } else {
                        if (customClassLoader != null) {
                            Map map = customClassLoader.classMap;
                            if (map.get(urlresource) != null) {
                                Class jspBaseCls = customClassLoader.loadClass((String) map.get(urlresource));
                                HttpJspBase jspBase = (HttpJspBase) jspBaseCls.newInstance();
                                WebServletConfig servletConfig = new WebServletConfig();
                                servletConfig.getServletContext().setAttribute(
                                        "org.apache.tomcat.InstanceManager",
                                        new WebInstanceManager(urlresource));
                                //servletConfig.getServletContext().setAttribute(org.apache.tomcat.InstanceManager, arg1);
                                jspBase.init(servletConfig);
                                jspBase._jspInit();
                                Response response = new Response(httpHeaderClient);
                                StringBuffer servletPath = new StringBuffer();
                                if (resourcepath.length > 1) {
                                    int pathcount = 0;
                                    for (String servPath : resourcepath) {
                                        if (pathcount > 1) {
                                            servletPath.append("/");
                                            servletPath.append(servPath);
                                        }
                                        pathcount++;
                                    }
                                }
                                String servletpath = servletPath.toString();
                                if (servletpath.length() == 0)
                                    servletpath = "/";
                                jspBase._jspService(
                                        new Request(httpHeaderClient, session, servletpath, customClassLoader),
                                        response);
                                jspBase.destroy();
                                response.flushBuffer();
                                return response.getResponse();
                            }
                        }
                    }
                }
            } catch (Exception ex) {
                ex.printStackTrace();

            } finally {
                if (oldCL != null) {
                    Thread.currentThread().setContextClassLoader(oldCL);
                }
            }
            File file = new File(deployDirectory + "/" + resourcepath[1] + "/WEB-INF/executor-config.xml");
            if (!file.exists()) {
                return null;
            }
            WebClassLoader customClassLoader = (WebClassLoader) urlClassLoaderMap
                    .get(deployDirectory + "/" + resourcepath[1]);
            Class customClass = null;
            if ((file.isFile() && file.exists())) {
                synchronized (serverdigester) {
                    serverconfig = (com.web.server.Executors) serverdigester.parse(file);
                }
                ConcurrentHashMap urlMap = serverconfig.getExecutorMap();
                //System.out.println("ObtainUrlFromResource1");

                //logger.info("urlresource"+urlresource);
                Executor executor = (Executor) urlMap.get(urlresource);

                //System.out.println("ObtainUrlFromResource2"+executor);
                //System.out.println("custom class Loader1"+urlClassLoaderMap);
                //System.out.println("custom class Loader2"+customClassLoader);                     //System.out.println("CUSTOM CLASS lOADER path"+deployDirectory+"/"+resourcepath[1]);
                ////System.out.println("custom class loader" +customClassLoader);                
                if (executor != null && customClassLoader != null) {
                    customClass = customClassLoader.loadClass(executor.getExecutorclass());
                    ExecutorInterface executorInstance = (ExecutorInterface) customClass.newInstance();
                    Object buffer = null;
                    if (httpHeaderClient.getHttpMethod().trim().toUpperCase().equals("GET")) {
                        buffer = executorInstance.doGet(httpHeaderClient);
                    } else if (httpHeaderClient.getHttpMethod().trim().toUpperCase().equals("POST")) {
                        buffer = executorInstance.doPost(httpHeaderClient);
                    }
                    if (executor.getResponseResource() != null) {
                        httpHeaderClient.setExecutorBuffer(buffer);
                        //System.out.println("Method:"+httpHeaderClient.getHttpMethod());
                        String resourceClass = (String) customClassLoader.getClassMap()
                                .get(executor.getResponseResource().trim());
                        customClass = customClassLoader.loadClass(resourceClass);
                        HttpJspBase jspBase = (HttpJspBase) customClass.newInstance();
                        WebServletConfig servletConfig = new WebServletConfig();
                        servletConfig.getServletContext().setAttribute("org.apache.tomcat.InstanceManager",
                                new WebInstanceManager(urlresource));
                        //servletConfig.getServletContext().setAttribute(org.apache.tomcat.InstanceManager, arg1);
                        jspBase.init(servletConfig);
                        jspBase._jspInit();
                        Response response = new Response(httpHeaderClient);
                        jspBase._jspService(new Request(httpHeaderClient, session, null, customClassLoader),
                                response);
                        jspBase.destroy();
                        response.flushBuffer();
                        return response.getResponse();
                    }
                    return buffer.toString().getBytes();
                }
            } else if (customClassLoader != null) {
                //System.out.println("url resource"+urlresource);
                String resourceClass = (String) customClassLoader.getClassMap().get(urlresource);
                //System.out.println(resourceClass);
                //System.out.println(customClassLoader.getClassMap());
                if (resourceClass == null)
                    return null;
                customClass = customClassLoader.loadClass(resourceClass);
                ExecutorInterface executorInstance = (ExecutorInterface) customClass.newInstance();
                Object buffer = executorInstance.doGet(httpHeaderClient);
                return buffer.toString().getBytes();
            }
            ////System.out.println("executor resource 1");
            //Object buffer = method.invoke(customClass.newInstance(), new Object[]{httpHeaderClient});

            // //logger.info(buffer.toString());

        } catch (IOException | SAXException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } /*catch (InvocationTargetException e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
          } catch (NoSuchMethodException e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
          } */catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    return null;
}