* HttpServer hs = new HttpServer("/var/www");
try{
ServletHandler sa = new ServletHandler();
sa.setRootFolder("/Path/To/Exploded/War/File");
sa.setServlet(new MyServlet());
// Set the Servlet's Name
// Any ServletConfig.getXXX method can be configured using this call.
// The same apply for ServletContext.getXXX.
sa.setProperty("display-name","myServlet");
sa.addListener("foo.bar.myHttpSessionListener");
sa.addListener(MyOtherHttpSessionListener.class);
sa.addServletContextListener(new FooServletContextListener());
sa.addServletContextAttributeListener(new BarServletCtxAttListener());
sa.addContextParameter("databaseURI","jdbc://");
sa.addInitParameter("password","hello");
sa.setServletPath("/MyServletPath");
sa.setContextPath("/myApp");
hs.getServerConfiguration().addHttpHandler(sa, "/MyServletPath);
hs.start();
} catch (IOException ex){
// Something when wrong.
}
* This method will return an empty string ("") if the
* servlet used to process this request was matched using
* the "/*" pattern.
*
* @return a String containing
* the name or path of the servlet being
* called, as specified in the request URL,
* decoded, or an empty string if the servlet
* used to process the request is matched
* using the "/*" pattern.
*
*/
public String getServletPath() {
return servletPath;
}
/**
* Programmatically set the servlet path of the Servlet.
*
* @param servletPath Path of {@link Servlet}.
*/
public void setServletPath(String servletPath) {
this.servletPath = servletPath;
if (servletPath.length() != 0 && !servletPath.startsWith("/")) {
servletPath = "/" + servletPath;
}
}
/**
*
* Returns the portion of the request URI that indicates the context
* of the request. The context path always comes first in a request
* URI. The path starts with a "/" character but does not end with a "/"
* character. For servlets in the default (root) context, this method
* returns "". The container does not decode this string.
*
*
It is possible that a servlet container may match a context by
* more than one context path. In such cases this method will return the
* actual context path used by the request and it may differ from the
* path returned by the
* {@link javax.servlet.ServletContext#getContextPath()} method.
* The context path returned by
* {@link javax.servlet.ServletContext#getContextPath()}
* should be considered as the prime or preferred context path of the
* application.
*
* @return a String specifying the
* portion of the request URI that indicates the context
* of the request
*
* @see javax.servlet.ServletContext#getContextPath()
*/
public String getContextPath() {
return contextPath;
}
/**
* Programmatically set the context path of the Servlet.
*
* @param contextPath Context path.
*/
public void setContextPath(String contextPath) {
this.contextPath = contextPath;
}
/**
* Add Servlet listeners that implement {@link EventListener}
*
* @param listenerName name of a Servlet listener
*/
public void addServletListener(String listenerName) {
if (listenerName == null) {
return;
}
listeners.add(listenerName);
}
/**
* Remove Servlet listeners that implement {@link EventListener}
*
* @param listenerName name of a Servlet listener to remove
*/
public boolean removeServletListener(String listenerName) {
return listenerName != null && listeners.remove(listenerName);
}
/**
* Use reflection to configure Object setter.
*
* @param object Populate this object with available properties.
*/
private void configureProperties(Object object) {
for (String s : properties.keySet()) {
String value = properties.get(s).toString();
IntrospectionUtils.setProperty(object, s, value);
}
}
/**
* Return a configured property. Property apply to
* {@link ServletContextImpl}
* and {@link ServletConfigImpl}
*
* @param name Name of property to get.
* @return Value of property.
*/
public Object getProperty(String name) {
return properties.get(name);
}
/**
* Set a configured property. Property apply to
* {@link ServletContextImpl}
* and {@link ServletConfigImpl}.
* Use this method to map what's you usually
* have in a web.xml like display-name, context-param, etc.
* @param name Name of the property to set
* @param value of the property.
*/
public void setProperty(String name, Object value) {
/**
* Servlet 2.4 specs
*
* If the value is a negative integer,
* or the element is not present, the container is free to load the
* servlet whenever it chooses. If the value is a positive integer
* or 0, the container must load and initialize the servlet as the
* application is deployed.
*/
if (name.equalsIgnoreCase(LOAD_ON_STARTUP) && value != null) {
if (value instanceof Boolean && ((Boolean) value)) {
loadOnStartup = true;
} else {
try {
if ((new Integer(value.toString())) >= 0) {
loadOnStartup = true;
}
} catch (Exception ignored) {
}
}
}
// Get rid of "-";
int pos = name.indexOf("-");
if (pos > 0) {
String pre = name.substring(0, pos);
String post = name.substring(pos + 1, pos + 2).toUpperCase() + name.substring(pos + 2);
name = pre + post;
}
properties.put(name, value);
}
/**
* Remove a configured property. Property apply to
* {@link ServletContextImpl}
* and {@link ServletConfigImpl}
*
* @param name Property name to remove.
*/
public void removeProperty(String name) {
properties.remove(name);
}
/**
*
* @return is the servlet will be loaded at startup
*/
public boolean isLoadOnStartup() {
return loadOnStartup;
}
/**
* Destroy this Servlet and its associated
* {@link javax.servlet.ServletContextListener}
*/
@Override
public void destroy() {
if (classLoader != null) {
ClassLoader prevClassLoader = Thread.currentThread().getContextClassLoader();
Thread.currentThread().setContextClassLoader(classLoader);
try {
super.destroy();
servletCtx.destroyListeners();
for (FilterConfigImpl filter : filters) {
if (filter != null) {
filter.recycle();
}
}
if (servletInstance != null) {
servletInstance.destroy();
// servletInstance = null;
}
// filters = null;
} finally {
Thread.currentThread().setContextClassLoader(prevClassLoader);
}
} else {
super.destroy();
servletCtx.destroyListeners();
}
}
/**
* Create a new {@link ServletHandler} instance that will share the same
* {@link ServletContextImpl} and Servlet's
* listener but with an empty map of init-parameters.
*
* @param servlet - The Servlet associated with the {@link ServletHandler}
* @return a new {@link ServletHandler}
*/
public ServletHandler newServletHandler(Servlet servlet) {
final String servletName = servlet.getServletConfig() != null ?
servlet.getServletConfig().getServletName() : null;
ServletHandler sa = new ServletHandler(
servletName,
servletCtx, contextParameters,
new HashMapjavax.servlet.FilterChain used to manage
* the execution of a set of filters for a particular request. When the
* set of defined filters has all been executed, the next call to
* doFilter() will execute the servlet's service()
* method itself.
*
* @author Craig R. McClanahan
*/
private final class FilterChainImpl implements FilterChain {
/**
* The servlet instance to be executed by this chain.
*/
private final Servlet servlet;
private final ServletConfigImpl configImpl;
private final FilterConfigImpl[] filters;
private final int n;
/**
* The int which is used to maintain the current position
* in the filter chain.
*/
private int pos = 0;
public FilterChainImpl(final Servlet servlet,
final ServletConfigImpl configImpl,
final FilterConfigImpl[] filters, final int n) {
this.servlet = servlet;
this.configImpl = configImpl;
this.filters = filters;
this.n = n;
}
// ---------------------------------------------------- FilterChain Methods
protected void invokeFilterChain(ServletRequest request, ServletResponse response)
throws IOException, ServletException {
ServletRequestEvent event =
new ServletRequestEvent(configImpl.getServletContext(), request);
try {
for (EventListener l : ((ServletContextImpl) configImpl.getServletContext()).getListeners()) {
try {
if (l instanceof ServletRequestListener) {
((ServletRequestListener) l).requestInitialized(event);
}
} catch (Throwable t) {
if (LOGGER.isLoggable(Level.WARNING)) {
LOGGER.log(Level.WARNING,
LogMessages.WARNING_GRIZZLY_HTTP_SERVLET_CONTAINER_OBJECT_INITIALIZED_ERROR("requestInitialized", "ServletRequestListener", l.getClass().getName()),
t);
}
}
}
pos = 0;
doFilter(request, response);
} finally {
for (EventListener l : ((ServletContextImpl) configImpl.getServletContext()).getListeners()) {
try {
if (l instanceof ServletRequestListener) {
((ServletRequestListener) l).requestDestroyed(event);
}
} catch (Throwable t) {
if (LOGGER.isLoggable(Level.WARNING)) {
LOGGER.log(Level.WARNING,
LogMessages.WARNING_GRIZZLY_HTTP_SERVLET_CONTAINER_OBJECT_DESTROYED_ERROR("requestDestroyed", "ServletRequestListener", l.getClass().getName()),
t);
}
}
}
}
}
/**
* Invoke the next filter in this chain, passing the specified request
* and response. If there are no more filters in this chain, invoke
* the service() method of the servlet itself.
*
* @param request The servlet request we are processing
* @param response The servlet response we are creating
*
* @exception java.io.IOException if an input/output error occurs
* @exception javax.servlet.ServletException if a servlet exception occurs
*/
@Override
public void doFilter(ServletRequest request, ServletResponse response)
throws IOException, ServletException {
// Call the next filter if there is one
if (pos < n) {
FilterConfigImpl filterConfig = filters[pos++];
try {
Filter filter = filterConfig.getFilter();
filter.doFilter(request, response, this);
} catch (IOException e) {
throw e;
} catch (ServletException e) {
throw e;
} catch (RuntimeException e) {
throw e;
} catch (Throwable e) {
throw new ServletException("Throwable", e);
}
return;
}
try {
if (servlet != null) {
servlet.service(request, response);
}
} catch (IOException e) {
throw e;
} catch (ServletException e) {
throw e;
} catch (RuntimeException e) {
throw e;
} catch (Throwable e) {
throw new ServletException("Throwable", e);
}
}
// -------------------------------------------------------- Package Methods
protected FilterConfigImpl getFilter(int i) {
return filters[i];
}
protected Servlet getServlet() {
return servlet;
}
protected ServletConfigImpl getServletConfig() {
return configImpl;
}
}
/**
* AfterServiceListener, which is responsible for recycle servlet request and response
* objects.
*/
static final class ServletAfterServiceListener implements AfterServiceListener {
@Override
public void onAfterService(final Request request) {
final HttpServletRequestImpl servletRequest = request.getNote(SERVLET_REQUEST_NOTE);
final HttpServletResponseImpl servletResponse = request.getNote(SERVLET_RESPONSE_NOTE);
if (servletRequest != null) {
servletRequest.recycle();
servletResponse.recycle();
}
}
}
}