Example usage for javax.servlet Servlet init

List of usage examples for javax.servlet Servlet init

  1. HOME
  2. Java
  3. javax
  4. javax.servlet.*
  5. Servlet
  6. init

Introduction

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

Prototype


public void init(ServletConfig config) throws ServletException;

Source Link

Document

Called by the servlet container to indicate to a servlet that the servlet is being placed into service.

Usage

From source file:org.jclouds.demo.tweetstore.config.SpringServletConfig.java

private void injectServletConfig(Servlet servlet) {
    LOGGER.trace("About to inject servlet config '%s'", servletConfig);
    try {// w w  w. j  a v  a  2 s  . co  m
        servlet.init(checkNotNull(servletConfig));
    } catch (ServletException exception) {
        throw new BeanCreationException("Unable to instantiate " + servlet, exception);
    }
    LOGGER.trace("Successfully injected servlet config.");
}

From source file:com.github.jrialland.ajpclient.AbstractTomcatTest.java

/**
 * binds a servlet on the tomcat instance. the 'mapping' has the same format
 * that the 'servlet-mapping' parameter in web.xml. the path of the servlet
 * will be relative to //*  ww w  .j  a  v a  2s .c o  m*/
 *
 * {@link Servlet#init(javax.servlet.ServletConfig)} is called with a mock
 * object as parameter.
 *
 * @param mapping
 * @param servlet
 */
protected void addServlet(final String mapping, final Servlet servlet) {
    final MockServletContext servletContext = new MockServletContext("/");
    final MockServletConfig config = new MockServletConfig(servletContext, servlet.toString());
    try {
        servlet.init(config);
    } catch (final Exception e) {
        throw new IllegalStateException(e);
    }
    servlets.put(mapping, servlet);
}

From source file:net.lightbody.bmp.proxy.jetty.jetty.servlet.ServletHolder.java

private void initServlet(Servlet servlet, ServletConfig config) throws ServletException {
    Principal user = null;//from   ww  w .  j  a  va2s.c o m
    try {
        // Handle run as
        if (_runAs != null && _realm != null)
            user = _realm.pushRole(null, _runAs);
        servlet.init(config);
    } finally {
        // pop run-as role
        if (_runAs != null && _realm != null && user != null)
            _realm.popRole(user);
    }
}

From source file:org.ireland.jnetty.dispatch.servlet.ServletConfigImpl.java

private Servlet createServletAndInit() throws ServletException {

    Class<? extends Servlet> servletClass = getServletClass();

    Servlet servlet;

    if (servletClass == null)
        throw new ServletException("Null servlet class for " + _servletName);

    try {/* w ww  .ja va  2 s.  co  m*/
        servlet = servletClass.newInstance();
    } catch (Exception e) {
        throw new ServletException(e);
    }

    // ?Servlet
    configureServlet(servlet);

    //?
    servlet.init(this);

    if (debug)
        log.debug("Servlet[" + _servletName + "] instantiated and inited");

    return servlet;
}

From source file:org.apache.catalina.core.StandardWrapper.java

/**
 * Load and initialize an instance of this servlet, if there is not already
 * at least one initialized instance.  This can be used, for example, to
 * load servlets that are marked in the deployment descriptor to be loaded
 * at server startup time.//from  w w w  .ja va  2s .  c om
 */
public synchronized Servlet loadServlet() throws ServletException {

    // Nothing to do if we already have an instance or an instance pool
    if (!singleThreadModel && (instance != null))
        return instance;

    PrintStream out = System.out;
    if (swallowOutput) {
        SystemLogHandler.startCapture();
    }

    Servlet servlet;
    try {
        long t1 = System.currentTimeMillis();
        // If this "servlet" is really a JSP file, get the right class.
        // HOLD YOUR NOSE - this is a kludge that avoids having to do special
        // case Catalina-specific code in Jasper - it also requires that the
        // servlet path be replaced by the <jsp-file> element content in
        // order to be completely effective
        String actualClass = servletClass;
        if ((actualClass == null) && (jspFile != null)) {
            Wrapper jspWrapper = (Wrapper) ((Context) getParent()).findChild(Constants.JSP_SERVLET_NAME);
            if (jspWrapper != null)
                actualClass = jspWrapper.getServletClass();
        }

        // Complain if no servlet class has been specified
        if (actualClass == null) {
            unavailable(null);
            throw new ServletException(sm.getString("standardWrapper.notClass", getName()));
        }

        // Acquire an instance of the class loader to be used
        Loader loader = getLoader();
        if (loader == null) {
            unavailable(null);
            throw new ServletException(sm.getString("standardWrapper.missingLoader", getName()));
        }

        ClassLoader classLoader = loader.getClassLoader();

        // Special case class loader for a container provided servlet
        //  
        if (isContainerProvidedServlet(actualClass) && !((Context) getParent()).getPrivileged()) {
            // If it is a priviledged context - using its own
            // class loader will work, since it's a child of the container
            // loader
            classLoader = this.getClass().getClassLoader();
        }

        // Load the specified servlet class from the appropriate class loader
        Class classClass = null;
        try {
            if (System.getSecurityManager() != null) {
                final ClassLoader fclassLoader = classLoader;
                final String factualClass = actualClass;
                try {
                    classClass = (Class) AccessController.doPrivileged(new PrivilegedExceptionAction() {
                        public Object run() throws Exception {
                            if (fclassLoader != null) {
                                return fclassLoader.loadClass(factualClass);
                            } else {
                                return Class.forName(factualClass);
                            }
                        }
                    });
                } catch (PrivilegedActionException pax) {
                    Exception ex = pax.getException();
                    if (ex instanceof ClassNotFoundException) {
                        throw (ClassNotFoundException) ex;
                    } else {
                        getServletContext().log("Error loading " + fclassLoader + " " + factualClass, ex);
                    }
                }
            } else {
                if (classLoader != null) {
                    classClass = classLoader.loadClass(actualClass);
                } else {
                    classClass = Class.forName(actualClass);
                }
            }
        } catch (ClassNotFoundException e) {
            unavailable(null);

            getServletContext().log("Error loading " + classLoader + " " + actualClass, e);
            throw new ServletException(sm.getString("standardWrapper.missingClass", actualClass), e);
        }

        if (classClass == null) {
            unavailable(null);
            throw new ServletException(sm.getString("standardWrapper.missingClass", actualClass));
        }

        // Instantiate and initialize an instance of the servlet class itself
        try {
            servlet = (Servlet) classClass.newInstance();
        } catch (ClassCastException e) {
            unavailable(null);
            // Restore the context ClassLoader
            throw new ServletException(sm.getString("standardWrapper.notServlet", actualClass), e);
        } catch (Throwable e) {
            unavailable(null);
            // Restore the context ClassLoader
            throw new ServletException(sm.getString("standardWrapper.instantiate", actualClass), e);
        }

        // Check if loading the servlet in this web application should be
        // allowed
        if (!isServletAllowed(servlet)) {
            throw new SecurityException(sm.getString("standardWrapper.privilegedServlet", actualClass));
        }

        // Special handling for ContainerServlet instances
        if ((servlet instanceof ContainerServlet)
                && (isContainerProvidedServlet(actualClass) || ((Context) getParent()).getPrivileged())) {
            ((ContainerServlet) servlet).setWrapper(this);
        }

        classLoadTime = (int) (System.currentTimeMillis() - t1);
        // Call the initialization method of this servlet
        try {
            instanceSupport.fireInstanceEvent(InstanceEvent.BEFORE_INIT_EVENT, servlet);

            if (System.getSecurityManager() != null) {
                Class[] classType = new Class[] { ServletConfig.class };
                Object[] args = new Object[] { ((ServletConfig) facade) };
                SecurityUtil.doAsPrivilege("init", servlet, classType, args);
            } else {
                servlet.init(facade);
            }

            // Invoke jspInit on JSP pages
            if ((loadOnStartup >= 0) && (jspFile != null)) {
                // Invoking jspInit
                DummyRequest req = new DummyRequest();
                req.setServletPath(jspFile);
                req.setQueryString("jsp_precompile=true");
                DummyResponse res = new DummyResponse();

                if (System.getSecurityManager() != null) {
                    Class[] classType = new Class[] { ServletRequest.class, ServletResponse.class };
                    Object[] args = new Object[] { req, res };
                    SecurityUtil.doAsPrivilege("service", servlet, classType, args);
                } else {
                    servlet.service(req, res);
                }
            }
            instanceSupport.fireInstanceEvent(InstanceEvent.AFTER_INIT_EVENT, servlet);
        } catch (UnavailableException f) {
            instanceSupport.fireInstanceEvent(InstanceEvent.AFTER_INIT_EVENT, servlet, f);
            unavailable(f);
            throw f;
        } catch (ServletException f) {
            instanceSupport.fireInstanceEvent(InstanceEvent.AFTER_INIT_EVENT, servlet, f);
            // If the servlet wanted to be unavailable it would have
            // said so, so do not call unavailable(null).
            throw f;
        } catch (Throwable f) {
            getServletContext().log("StandardWrapper.Throwable", f);
            instanceSupport.fireInstanceEvent(InstanceEvent.AFTER_INIT_EVENT, servlet, f);
            // If the servlet wanted to be unavailable it would have
            // said so, so do not call unavailable(null).
            throw new ServletException(sm.getString("standardWrapper.initException", getName()), f);
        }

        // Register our newly initialized instance
        singleThreadModel = servlet instanceof SingleThreadModel;
        if (singleThreadModel) {
            if (instancePool == null)
                instancePool = new Stack();
        }
        fireContainerEvent("load", this);

        loadTime = System.currentTimeMillis() - t1;
    } finally {
        if (swallowOutput) {
            String log = SystemLogHandler.stopCapture();
            if (log != null && log.length() > 0) {
                if (getServletContext() != null) {
                    getServletContext().log(log);
                } else {
                    out.println(log);
                }
            }
        }
    }
    return servlet;

}

From source file:org.apache.sling.servlets.resolver.internal.SlingServletResolver.java

/**
 * Returns the internal default servlet which is called in case no other
 * servlet applies for handling a request. This servlet should really only
 * be used if the default servlets have not been registered (yet).
 *//*  www .  j a  v  a 2 s .c  o  m*/
private Servlet getDefaultServlet() {
    if (defaultServlet == null) {
        try {
            Servlet servlet = new DefaultServlet();
            servlet.init(new SlingServletConfig(servletContext, null, "Apache Sling Core Default Servlet"));
            defaultServlet = servlet;
        } catch (final ServletException se) {
            LOGGER.error("Failed to initialize default servlet", se);
        }
    }

    return defaultServlet;
}

From source file:org.apache.sling.servlets.resolver.internal.SlingServletResolver.java

/**
 * Returns the default error handler servlet, which is called in case there
 * is no other - better matching - servlet registered to handle an error or
 * exception.//from  w w  w. j av a  2s  . c o m
 * <p>
 * The default error handler servlet is registered for the resource type
 * "sling/servlet/errorhandler" and method "default". This may be
 * overwritten by applications globally or according to the resource type
 * hierarchy of the resource.
 * <p>
 * If no default error handler servlet can be found an adhoc error handler
 * is used as a final fallback.
 */
private Servlet getDefaultErrorServlet(final SlingHttpServletRequest request, final Resource resource,
        final ResourceResolver resolver) {

    // find a default error handler according to the resource type
    // tree of the given resource
    final ResourceCollector locationUtil = new ResourceCollector(
            ServletResolverConstants.DEFAULT_ERROR_HANDLER_NAME, ServletResolverConstants.ERROR_HANDLER_PATH,
            resource, this.executionPaths);
    final Servlet servlet = getServletInternal(locationUtil, request, resolver);
    if (servlet != null) {
        return servlet;
    }

    // if no registered default error handler could be found use
    // the DefaultErrorHandlerServlet as an ad-hoc fallback
    if (fallbackErrorServlet == null) {
        // fall back to an adhoc instance of the DefaultErrorHandlerServlet
        // if the actual service is not registered (yet ?)
        try {
            final Servlet defaultServlet = new DefaultErrorHandlerServlet();
            defaultServlet.init(new SlingServletConfig(servletContext, null,
                    "Sling (Ad Hoc) Default Error Handler Servlet"));
            fallbackErrorServlet = defaultServlet;
        } catch (ServletException se) {
            LOGGER.error("Failed to initialize error servlet", se);
        }
    }
    return fallbackErrorServlet;
}

From source file:org.apache.sling.servlets.resolver.internal.SlingServletResolver.java

private boolean createServlet(final ServiceReference reference) {

    // check for a name, this is required
    final String name = getName(reference);
    if (name == null) {
        LOGGER.error("bindServlet: Cannot register servlet {} without a servlet name", reference);
        return false;
    }/*from   w  w  w .  ja v a  2 s  .  co m*/

    // check for Sling properties in the service registration
    ServletResourceProvider provider = servletResourceProviderFactory.create(reference);
    if (provider == null) {
        // this is expected if the servlet is not destined for Sling
        return false;
    }

    // only now try to access the servlet service, this may still fail
    Servlet servlet = null;
    try {
        servlet = (Servlet) context.locateService(REF_SERVLET, reference);
    } catch (Throwable t) {
        LOGGER.warn("bindServlet: Failed getting the service for reference " + reference, t);
    }
    if (servlet == null) {
        LOGGER.error("bindServlet: Servlet service not available from reference {}", reference);
        return false;
    }

    // assign the servlet to the provider
    provider.setServlet(servlet);

    // initialize now
    try {
        servlet.init(new SlingServletConfig(servletContext, reference, name));
        LOGGER.debug("bindServlet: Servlet {} added", name);
    } catch (ServletException ce) {
        LOGGER.error("bindServlet: Component " + name + " failed to initialize", ce);
        return false;
    } catch (Throwable t) {
        LOGGER.error("bindServlet: Unexpected problem initializing component " + name, t);
        return false;
    }

    final List<ServiceRegistration> regs = new ArrayList<ServiceRegistration>();
    for (final String root : provider.getServletPaths()) {
        final ServiceRegistration reg = context.getBundleContext().registerService(
                ResourceProvider.class.getName(), provider, createServiceProperties(reference, provider, root));
        regs.add(reg);
    }
    LOGGER.debug("Registered {}", provider.toString());
    synchronized (this.servletsByReference) {
        servletsByReference.put(reference, new ServletReg(servlet, regs));
    }
    return true;
}

From source file:org.apache.struts2.JSPLoader.java

/**
 * Creates and inits a servlet// w w  w .  j a  va2  s . c  o  m
 */
private Servlet createServlet(Class clazz)
        throws IllegalAccessException, InstantiationException, ServletException {
    JSPServletConfig config = new JSPServletConfig(ServletActionContext.getServletContext());

    Servlet servlet = (Servlet) clazz.newInstance();
    servlet.init(config);

    /*
     there is no need to call JspPage.init explicitly because Jasper's
     JSP base classe HttpJspBase.init(ServletConfig) calls:
     jspInit();
     _jspInit();
     */

    return servlet;
}

From source file:org.massyframework.assembly.servlet.jasper.JasparResourceProessor.java

/**
 * ???JspServlet// w  w w. ja  va2  s  . co  m
 * @param assembly ?
 * @return {@link JspServlet}
 */
@SuppressWarnings("unchecked")
private Servlet getOrCreateJspServelt(HttpResource resource) throws ServletException {
    Servlet result = this.servletMap.get(resource.getAssembly());
    if (result == null) {
        try {
            synchronized (this) {
                if (result == null) {
                    MixinClassLoader jasperLoader = new MixinClassLoader(resource.getAssemblyClassLoader(),
                            this.getClass().getClassLoader());

                    if (this.servletClass == null) {
                        this.servletClass = (Class<? extends Servlet>) jasperLoader
                                .loadClass("org.apache.jasper.servlet.JspServlet");
                    }
                    Servlet tmp = ClassLoaderUtils.newInstance(this.servletClass);

                    ClassLoader loader = ClassLoaderUtils.setThreadContextClassLoader(jasperLoader);
                    try {

                        Context context = new Context(jasperLoader,
                                LoggerReference.adaptFrom(resource.getAssembly()));
                        context.scanTlds();
                        tmp.init(new Config(context));

                        result = this.servletMap.putIfAbsent(resource.getAssembly(), tmp);
                        if (result == null) {
                            result = tmp;
                        }
                    } finally {
                        ClassLoaderUtils.setThreadContextClassLoader(loader);
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    return result;
}