Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
   *
   * Copyright (c) 2010-2011 Oracle and/or its affiliates. All rights reserved.
   *
   * The contents of this file are subject to the terms of either the GNU
   * General Public License Version 2 only ("GPL") or the Common Development
   * and Distribution License("CDDL") (collectively, the "License").  You
   * may not use this file except in compliance with the License.  You can
  * obtain a copy of the License at
  * http://glassfish.java.net/public/CDDL+GPL_1_1.html
  * or packager/legal/LICENSE.txt.  See the License for the specific
  * language governing permissions and limitations under the License.
  *
  * When distributing the software, include this License Header Notice in each
  * file and include the License file at packager/legal/LICENSE.txt.
  *
  * GPL Classpath Exception:
  * Oracle designates this particular file as subject to the "Classpath"
  * exception as provided by Oracle in the GPL Version 2 section of the License
  * file that accompanied this code.
  *
  * Modifications:
  * If applicable, add the following below the License Header, with the fields
  * enclosed by brackets [] replaced by your own identifying information:
  * "Portions Copyright [year] [name of copyright owner]"
  *
  * Contributor(s):
  * If you wish your version of this file to be governed by only the CDDL or
  * only the GPL Version 2, indicate your decision by adding "[Contributor]
  * elects to include this software in this distribution under the [CDDL or GPL
  * Version 2] license."  If you don't indicate a single choice of license, a
  * recipient has the option to distribute your version of this file under
  * either the CDDL, the GPL Version 2 or to extend the choice of license to
  * its licensees as provided above.  However, if you add GPL Version 2 code
  * and therefore, elected the GPL Version 2 license, then the option applies
  * only if the new code is made subject to such option by the copyright
  * holder.
  */
 package com.sun.jersey.server.impl.container.servlet;
 
 
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 /*
 It is RECOMMENDED that implementations support the Servlet 3 framework 
  pluggability mechanism to enable portability between containers and to avail
  themselves of container-supplied class scanning facilities.
  When using the pluggability mechanism the following conditions MUST be met:
 
 - If no Application subclass is present the added servlet MUST be
  named "javax.ws.rs.core.Application" and all root resource classes and
  providers packaged in the web application MUST be included in the published
  JAX-RS application. The application MUST be packaged with a web.xml that
  specifies a servlet mapping for the added servlet.
 
 - If an Application subclass is present and there is already a servlet defined
  that has a servlet initialization parameter named "javax.ws.rs.Application"
  whose value is the fully qualified name of the Application subclass then no
  servlet should be added by the JAX-RS implementation's ContainerInitializer
  since the application is already being handled by an existing servlet.
 
 - If an application subclass is present that is not being handled by an
  existing servlet then the servlet added by the ContainerInitializer MUST be
  named with the fully qualified name of the Application subclass.  If the
  Application subclass is annotated with @PathPrefix and no servlet-mapping
  exists for the added servlet then a new servlet mapping is added with the
  value of the @PathPrefix  annotation with "/*" appended otherwise the existing
  mapping is used. If the Application subclass is not annotated with @PathPrefix
  then the application MUST be packaged with a web.xml that specifies a servlet
  mapping for the added servlet. It is an error for more than one Application
  to be deployed at the same effective servlet mapping.
 
 In either of the latter two cases, if both Application#getClasses and
  Application#getSingletons return an empty list then all root resource classes
  and providers packaged in the web application MUST be included in the
  published JAX-RS application. If either getClasses or getSingletons return a
  non-empty list then only those classes or singletons returned MUST be included
  in the published JAX-RS application.
 
If not using the Servlet 3 framework pluggability mechanism
 (e.g. in a pre-Servet 3.0 container), the servlet-class or filter-class
 element of the web.xml descriptor SHOULD name the JAX-RS
 implementation-supplied Servlet or Filter class respectively. The
 application-supplied subclass of Application SHOULD be identied using an
 init-param with a param-name of javax.ws.rs.Application.
 
 */

Author(s):
Paul.Sandoz@Sun.Com
@HandlesTypes({Path.classProvider.classApplication.classApplicationPath.class})
    private static final Logger LOGGER =
            Logger.getLogger(JerseyServletContainerInitializer.class.getName());
    @Override
    public void onStartup(Set<Class<?>> classesServletContext sc) {
        if (classes == null) {
            classes = Collections.<Class<?>>emptySet();
        }
        final int nOfRegisterations = sc.getServletRegistrations().size();
        for (Class<? extends Applicationa : getApplicationClasses(classes)) {
            final ServletRegistration appReg = sc.getServletRegistration(a.getName());
            if (appReg != null) {
                // Servlet is registered with app name
                
                addServletWithExistingRegistration(scappRegaclasses);
            } else {
                // Servlet is not registered with app name
                final List<ServletRegistrationsrs = getInitParamDeclaredRegistrations(sca);
                if (!srs.isEmpty()) {
                    // List of servlets registered with app name in init param
                    
                    for (ServletRegistration sr : srs) {
                        addServletWithExistingRegistration(scsraclasses);
                    }
                } else {
                    addServletWithApplication(scaclasses);
                }
            }            
        }
        
        if (nOfRegisterations == sc.getServletRegistrations().size()) {
            // No app was registered
            addServletWithDefaultConfiguration(scclasses);
        }
    }
        final List<ServletRegistrationsrs = new ArrayList<ServletRegistration>(1);
        for (ServletRegistration sr : sc.getServletRegistrations().values()) {
            Map<StringStringips = sr.getInitParameters();
            if (ips.containsKey(.)) {
                if (ips.get(.).equals(a.getName())) {
                    if (sr.getClassName() == null) {
                        srs.add(sr);
                    }
                }
            } else if (ips.containsKey(.)) {
                if (ips.get(.).equals(a.getName())) {
                    if (sr.getClassName() == null) {
                        srs.add(sr);
                    }
                }
            }
        }
        return srs;
    }
    private void addServletWithDefaultConfiguration(ServletContext scSet<Class<?>> classes) {
        ServletRegistration appReg = sc.getServletRegistration(Application.class.getName());
        if (appReg != null && appReg.getClassName() == null) {
            final Set<Class<?>> x = getRootResourceAndProviderClasses(classes);
            final ServletContainer s = new ServletContainer(
                    new DefaultResourceConfig(x));
            appReg = sc.addServlet(appReg.getName(), s);
            if (appReg.getMappings().isEmpty()) {
                // Error
                .severe("The Jersey servlet application, named " +
                        appReg.getName() +
                        ", has no servlet mapping");
            } else {
                .info("Registering the Jersey servlet application, named " +
                        appReg.getName() +
                        ", with the following root resource and provider classes: " + x);
            }
        }
    }
    
    private void addServletWithApplication(ServletContext sc,
            Class<? extends ApplicationaSet<Class<?>> classes) {
        final ApplicationPath ap = a.getAnnotation(ApplicationPath.class);
        if (ap != null) {
            // App is annotated with ApplicationPath
            
            final ServletContainer s = new ServletContainer(
                    new DeferredResourceConfig(agetRootResourceAndProviderClasses(classes)));
            final String mapping = createMappingPath(ap);
            if (!mappingExists(scmapping)) {
                sc.addServlet(a.getName(), s).
                        addMapping(mapping);
                .info("Registering the Jersey servlet application, named " +
                        a.getName() +
                        ", at the servlet mapping, "
                        + mapping +
                        ", with the Application class of the same name");
            } else {
                .severe("Mapping conflict. " +
                        "A Servlet declaration exists with same mapping as the Jersey servlet application, named " +
                        a.getName() +
                        ", at the servlet mapping, "
                        + mapping +
                        ". The Jersey servlet is not deployed.");
            }
        }
    }
            Class<? extends ApplicationaSet<Class<?>> classes) {
        if (sr.getClassName() == null) {
            final ResourceConfig rc = new DeferredResourceConfig(agetRootResourceAndProviderClasses(classes));
            final Map<StringObjectinitParams = new HashMap<StringObject>();
            for(Map.Entry<StringStringentry : sr.getInitParameters().entrySet())
                initParams.put(entry.getKey(), entry.getValue());
            rc.setPropertiesAndFeatures(initParams);
            final ServletContainer s = new ServletContainer(rc);
            sr = sc.addServlet(a.getName(), s);
            if (sr.getMappings().isEmpty()) {
                final ApplicationPath ap = a.getAnnotation(ApplicationPath.class);
                if (ap != null) {
                    final String mapping = createMappingPath(ap);
                    if (!mappingExists(scmapping)) {
                        sr.addMapping(mapping);
                        .info("Registering the Jersey servlet application, named " +
                                a.getName() +
                                ", at the servlet mapping, "
                                + mapping +
                                ", with the Application class of the same name");
                    } else {
                        .severe("Mapping conflict. " +
                                "A Servlet registration exists with same mapping as the Jersey servlet application, named " +
                                a.getName() +
                                ", at the servlet mapping, "
                                + mapping +
                                ". The Jersey servlet is not deployed.");
                    }
                } else {
                    // Error
                    .severe("The Jersey servlet application, named " +
                            a.getName() +
                            ", is not annotated with " + ApplicationPath.class.getSimpleName() + " " +
                            "and has no servlet mapping");
                }
            } else {
                .info("Registering the Jersey servlet application, named " +
                        a.getName() +
                        ", with the Application class of the same name");
            }
        }
    }
    private boolean mappingExists(ServletContext scString mapping) {
        for (ServletRegistration sr : sc.getServletRegistrations().values()) {
            for (String declaredMapping : sr.getMappings()) {
                if (mapping.equals(declaredMapping)) {
                    return true;
                }
            }
        }
        return false;
    }
    private String createMappingPath(ApplicationPath ap) {
        String path = ap.value();
        if (!path.startsWith("/")) {
            path = "/" + path;
        }
        if (!path.endsWith("/*")) {
            if (path.endsWith("/")) {
                path += "*";
            } else {
                path += "/*";
            }
        }
        return path;
    }
    private Set<Class<? extends Application>> getApplicationClasses(Set<Class<?>> classes) {
        Set<Class<? extends Application>> s = new LinkedHashSet<Class<? extends Application>>();
        for (Class<?> c : classes) {
            if (Application.class != c && Application.class.isAssignableFrom(c)) {
                s.add(c.asSubclass(Application.class));
            }
        }
        return s;
    }
    private Set<Class<?>> getRootResourceAndProviderClasses(Set<Class<?>> classes) {
        // TODO filter out any classes from the Jersey jars
        Set<Class<?>> s = new LinkedHashSet<Class<?>>();
        for (Class<?> c : classes) {
            if (c.isAnnotationPresent(Path.class) || c.isAnnotationPresent(Provider.class))
                s.add(c);
        }
        return s;
    }
New to GrepCode? Check out our FAQ X