Comment enregistrer un servlet en Java

<welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<servlet>
    <servlet-name>Example</servlet-name>
    <servlet-class>com.baeldung.Example</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>Example</servlet-name>
    <url-pattern>/Example</url-pattern>
</servlet-mapping>

@WebServlet(
  name = "AnnotationExample",
  description = "Example Servlet Using Annotations",
  urlPatterns = {"/AnnotationExample"}
)
public class Example extends HttpServlet {

    @Override
    protected void doGet(
      HttpServletRequest request,
      HttpServletResponse response) throws ServletException, IOException {

        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        out.println("<p>Hello World!</p>");
    }
}

public class WebAppInitializer implements WebApplicationInitializer {

    public void onStartup(ServletContext container) throws ServletException {
        AnnotationConfigWebApplicationContext ctx
          = new AnnotationConfigWebApplicationContext();
        ctx.register(WebMvcConfigure.class);
        ctx.setServletContext(container);

        ServletRegistration.Dynamic servlet = container.addServlet(
          "dispatcherExample", new DispatcherServlet(ctx));
        servlet.setLoadOnStartup(1);
        servlet.addMapping("/");
     }
}

@Configuration
public class WebMvcConfigure implements WebMvcConfigurer {

    @Bean
    public ViewResolver getViewResolver() {
        InternalResourceViewResolver resolver
          = new InternalResourceViewResolver();
        resolver.setPrefix("/WEB-INF/");
        resolver.setSuffix(".jsp");
        return resolver;
    }

    @Override
    public void configureDefaultServletHandling(
      DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }

    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/resources/** ** ")
          .addResourceLocations("/resources/").setCachePeriod(3600)
          .resourceChain(true).addResolver(new PathResourceResolver());
    }
}

<servlet>
    <servlet-name>dispatcher</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/spring/dispatcher.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
    <servlet-name>dispatcher</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>

<beans ...>

    <context:component-scan base-package="com.baeldung"/>

    <bean
      class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>

public void onStartup(ServletContext container) throws ServletException {
   XmlWebApplicationContext xctx = new XmlWebApplicationContext();
   xctx.setConfigLocation('classpath:/context.xml');
   xctx.setServletContext(container);

   ServletRegistration.Dynamic servlet = container.addServlet(
     "dispatcher", new DispatcherServlet(ctx));
   servlet.setLoadOnStartup(1);
   servlet.addMapping("/");
}

<beans ...>

    <context:component-scan base-package="com.baeldung"/>
    <bean class="com.baeldung.configuration.WebAppInitializer"/>
</beans>

@Bean
public ServletRegistrationBean exampleServletBean() {
    ServletRegistrationBean bean = new ServletRegistrationBean(
      new CustomServlet(), "/exampleServlet/** ");
    bean.setLoadOnStartup(1);
    return bean;
}

public class CustomServlet extends HttpServlet{
    ...
}

servlet.name=dispatcherExample
servlet.mapping=/dispatcherExampleURL

System.setProperty("custom.config.location", "classpath:custom.properties");

System.getProperty("custom.config.location");

servlet.name=dispatcherExample
servlet.mapping=/dispatcherExampleURL

public Properties getProperties(String file) throws IOException {
  Properties prop = new Properties();
  InputStream input = null;
  input = getClass().getResourceAsStream(file);
  prop.load(input);
  if (input != null) {
      input.close();
  }
  return prop;
}

private static final PropertyLoader pl = new PropertyLoader();
private static final Properties springProps
  = pl.getProperties("custom__spring.properties");

public static final String SERVLET__NAME
  = springProps.getProperty("servlet.name");
public static final String SERVLET__MAPPING
  = springProps.getProperty("servlet.mapping");

ServletRegistration.Dynamic servlet = container.addServlet(
  SERVLET__NAME, new DispatcherServlet(ctx));
servlet.setLoadOnStartup(1);
servlet.addMapping(SERVLET__MAPPING);

@Configuration
@PropertySource("classpath:/com/yourapp/custom.properties")
public class ExampleCustomConfig {
    @Autowired
    ConfigurableEnvironment env;

    public String getProperty(String key) {
        return env.getProperty(key);
    }
}

ConfigurableEnvironment env = new StandardEnvironment();
MutablePropertySources props = env.getPropertySources();
Map map = new HashMap(); map.put("key", "value");
props.addFirst(new MapPropertySource("Map", map));

server.jsp-servlet.class-name=org.apache.jasper.servlet.JspServlet
server.jsp-servlet.registered=true
server.port=8080
server.servlet-path=/----

Vous trouverez ci-dessus certains paramètres d'application pouvant être utilisés pour configurer le partage de ressources __DispatcherServlet__ et statique. Les paramètres pour les servlets intégrées, la prise en charge de SSL et les sessions sont également disponibles.

Il y a vraiment trop de paramètres de configuration pour être listés ici, mais vous pouvez voir la liste complète dans https://docs.spring.io/spring-boot/docs/current/reference/html/common-application-properties.html[Spring Documentation de démarrage].

====  **  5.2. Configuration via YAML **

De même, nous pouvons configurer notre conteneur de servlets intégré à l'aide de YAML.

Cela nécessite l'utilisation d'un chargeur de propriétés YAML spécialisé - le __YamlPropertySourceLoader__ - qui expose notre YAML et permet aux clés et aux valeurs qu'il contient d'être utilisées dans notre application.

[source,java,gutter:,true]

====  **  5.3. Configuration par programme via TomcatEmbeddedServletContainerFactory **

La configuration par programme d'un conteneur de servlets intégré est possible via une instance sous-classée de __EmbeddedServletContainerFactory__. Par exemple, vous pouvez utiliser __TomcatEmbeddedServletContainerFactory__ pour configurer votre servlet Tomcat intégré.

__TomcatEmbeddedServletContainerFactory__ encapsule l'objet __org.apache.catalina.startup.Tomcat__ en fournissant des options de configuration supplémentaires:

[source,java,gutter:,true]

Ensuite, nous pouvons configurer l'instance renvoyée:

[source,java,gutter:,true]

Chacun de ces paramètres peut être configuré à l'aide de l'une des méthodes décrites précédemment.

Nous pouvons également accéder et manipuler directement l'objet __org.apache.catalina.startup.Tomcat__:

[source,java,gutter:,true]

===  **  6. Conclusion**

Dans cet article, nous avons passé en revue plusieurs méthodes pour **  enregistrer un servlet dans une application Java EE et Spring Boot. **

Le code source utilisé dans ce didacticiel est disponible dans le projet https://github.com/eugenp/tutorials/tree/master/spring-boot[Github].