Cara Mendaftar Servlet di Java

1. Perkenalan

Artikel ini akan memberikan gambaran umum tentang cara mendaftarkan servlet di Jakarta EE dan Spring Boot. Secara khusus, kita akan melihat dua cara untuk mendaftarkan Java Servlet di Jakarta EE - satu menggunakan file web.xml , dan yang lainnya menggunakan anotasi. Kemudian kami akan mendaftarkan servlet di Spring Boot menggunakan konfigurasi XML, konfigurasi Java, dan melalui properti yang dapat dikonfigurasi.

Artikel pengantar yang bagus tentang servlet dapat ditemukan di sini.

2. Mendaftarkan Servlet di Jakarta EE

Mari kita bahas dua cara untuk mendaftarkan servlet di Jakarta EE. Pertama, kita bisa mendaftarkan servlet melalui web.xml . Alternatifnya, kita bisa menggunakan anotasi Jakarta EE @WebServlet .

2.1. Melalui web.xml

Cara paling umum untuk mendaftarkan servlet dalam aplikasi Jakarta EE Anda adalah dengan menambahkannya ke file web.xml Anda :

 index.html index.htm index.jsp   Example com.baeldung.Example   Example /Example 

Seperti yang Anda lihat, ini melibatkan dua langkah: (1) menambahkan servlet kita ke tag servlet , pastikan juga untuk menentukan path sumber ke kelas servlet berada, dan (2) menentukan path URL servlet akan diekspos. di dalam tag pola url .

File Jakarta EE web.xml biasanya terdapat di WebContent / WEB-INF .

2.2. Melalui Anotasi

Sekarang mari kita daftarkan servlet kita menggunakan anotasi @WebServlet pada kelas servlet khusus kita. Ini menghilangkan kebutuhan akan pemetaan servlet di server.xml dan pendaftaran servlet di web.xml :

@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("

Hello World!

"); } }

Kode di atas menunjukkan bagaimana menambahkan anotasi itu secara langsung ke servlet. Servlet akan tetap tersedia di jalur URL yang sama seperti sebelumnya.

3. Mendaftarkan Servlet di Spring Boot

Sekarang kami telah menunjukkan cara mendaftar servlet di Jakarta EE, mari kita lihat beberapa cara untuk mendaftarkan servlet di aplikasi Spring Boot.

3.1. Pendaftaran Terprogram

Spring Boot mendukung 100% konfigurasi terprogram aplikasi web.

Pertama, kita akan mengimplementasikan antarmuka WebApplicationInitializer , kemudian mengimplementasikan antarmuka WebMvcConfigurer , yang memungkinkan Anda untuk mengganti default preset daripada harus menentukan setiap pengaturan konfigurasi tertentu, menghemat waktu dan memungkinkan Anda untuk bekerja dengan beberapa pengaturan yang sudah dicoba dan benar di luar -kotak.

Mari kita lihat contoh penerapan WebApplicationInitializer :

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("/"); } }

Selanjutnya, mari kita terapkan antarmuka WebMvcConfigurer :

@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()); } }

Di atas, kami menetapkan beberapa setelan default untuk servlet JSP secara eksplisit untuk mendukung tampilan .jsp dan penyajian resource statis.

3.2. Konfigurasi XML

Cara lain untuk mengkonfigurasi dan mendaftarkan servlet dalam Spring Boot adalah melalui web.xml :

 dispatcher org.springframework.web.servlet.DispatcherServlet  contextConfigLocation /WEB-INF/spring/dispatcher.xml  1   dispatcher / 

The web.xml yang digunakan untuk menentukan konfigurasi di Spring mirip dengan yang ditemukan di Jakarta EE. Di atas, Anda dapat melihat bagaimana kami menetapkan beberapa parameter lagi melalui atribut di bawah tag servlet .

Di sini kami menggunakan XML lain untuk menyelesaikan konfigurasi:

Ingatlah bahwa Spring web.xml Anda biasanya akan ada di src / main / webapp / WEB-INF .

3.3. Menggabungkan XML dan Registrasi Terprogram

Mari kita gabungkan pendekatan konfigurasi XML dengan konfigurasi terprogram Spring:

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("/"); }

Mari kita juga mengkonfigurasi servlet dispatcher:

3.4. Pendaftaran oleh Bean

Kita juga dapat mengkonfigurasi dan mendaftarkan servlet secara terprogram menggunakan ServletRegistrationBean . Di bawah ini kami akan melakukannya untuk mendaftarkan HttpServlet (yang mengimplementasikan antarmuka javax.servlet.Servlet ):

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

Keuntungan utama dari pendekatan ini adalah memungkinkan Anda untuk menambahkan beberapa servlet serta berbagai jenis servlet ke aplikasi Spring Anda.

Alih-alih hanya menggunakan DispatcherServlet, yang merupakan jenis HttpServlet yang lebih spesifik dan jenis yang paling umum digunakan dalam pendekatan programatik WebApplicationInitializer untuk konfigurasi yang kita pelajari di bagian 3.1, kita akan menggunakan instance subkelas HttpServlet yang lebih sederhana yang memperlihatkan empat operasi dasar HttpRequest melalui empat fungsi: doGet () , doPost () , doPut () , dan doDelete () seperti di Jakarta EE.

Ingatlah bahwa HttpServlet adalah kelas abstrak (jadi tidak bisa dipakai). Kami dapat menyiapkan ekstensi khusus dengan mudah, meskipun:

public class CustomServlet extends HttpServlet{ ... }

4. Mendaftarkan Servlet Dengan Properti

Another, though uncommon, way to configure and register your servlets is to use a custom properties file loaded into the app via a PropertyLoader, PropertySource, or PropertySources instance object.

This provides an intermediate kind of configuration and the ability to otherwise customize application.properties which provide little direct configuration for non-embedded servlets.

4.1. System Properties Approach

We can add some custom settings to our application.properties file or another properties file. Let's add a few settings to configure our DispatcherServlet:

servlet.name=dispatcherExample servlet.mapping=/dispatcherExampleURL

Let's load our custom properties into our application:

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

And now we can access those properties via:

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

4.2. Custom Properties Approach

Let's start with a custom.properties file:

servlet.name=dispatcherExample servlet.mapping=/dispatcherExampleURL

We can then use a run-of-the-mill Property Loader:

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; }

And now we can add these custom properties as constants to our WebApplicationInitializer implementation:

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");

We can then use them to, for example, configure our dispatcher servlet:

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

The advantage of this approach is the absence of .xml maintenance but with easy-to-modify configuration settings that don't require redeploying the codebase.

4.3. The PropertySource Approach

A faster way to accomplish the above is to make use of Spring's PropertySource which allows a configuration file to be accessed and loaded.

PropertyResolver is an interface implemented by ConfigurableEnvironment, which makes application properties available at servlet startup and initialization:

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

Above, we autowire a dependency into the class and specify the location of our custom properties file. We can then fetch our salient property by calling the function getProperty() passing in the String value.

4.4. The PropertySource Programmatic Approach

We can combine the above approach (which involves fetching property values) with the approach below (which allows us to programmatically specify those values):

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

We've created a map linking a key to a value then add that map to PropertySources enabling invocation as needed.

5. Registering Embedded Servlets

Lastly, we'll also take a look at basic configuration and registration of embedded servlets within Spring Boot.

An embedded servlet provides full web container (Tomcat, Jetty, etc.) functionality without having to install or maintain the web-container separately.

You can add the required dependencies and configuration for simple live server deployment wherever such functionality is supported painlessly, compactly, and quickly.

We'll only look at how to do this Tomcat but the same approach can be undertaken for Jetty and alternatives.

Let's specify the dependency for an embedded Tomcat 8 web container in pom.xml:

 org.apache.tomcat.embed tomcat-embed-core 8.5.11 

Now let's add the tags required to successfully add Tomcat to the .war produced by Maven at build-time:

 embeddedTomcatExample   org.codehaus.mojo appassembler-maven-plugin 2.0.0  target   launch.Main webapp      package  assemble      

If you are using Spring Boot, you can instead add Spring's spring-boot-starter-tomcat dependency to your pom.xml:

 org.springframework.boot spring-boot-starter-tomcat provided 

5.1. Registration Through Properties

Spring Boot supports configuring most possible Spring settings through application.properties. After adding the necessary embedded servlet dependencies to your pom.xml, you can customize and configure your embedded servlet using several such configuration options:

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

Above are some of the application settings that can be used to configure the DispatcherServlet and static resource sharing. Settings for embedded servlets, SSL support, and sessions are also available.

There are really too many configuration parameters to list here but you can see the full list in the Spring Boot documentation.

5.2. Configuration Through YAML

Similarly, we can configure our embedded servlet container using YAML. This requires the use of a specialized YAML property loader — the YamlPropertySourceLoader — which exposes our YAML and makes the keys and values therein available for use within our app.

YamlPropertySourceLoader sourceLoader = new YamlPropertySourceLoader(); PropertySource yamlProps = sourceLoader.load("yamlProps", resource, null);

5.3. Programmatic Configuration Through TomcatEmbeddedServletContainerFactory

Programmatic configuration of an embedded servlet container is possible through a subclassed instance of EmbeddedServletContainerFactory. For example, you can use the TomcatEmbeddedServletContainerFactory to configure your embedded Tomcat servlet.

The TomcatEmbeddedServletContainerFactory membungkus org.apache.catalina.startup.Tomcat objek menyediakan pilihan konfigurasi tambahan:

@Bean public ConfigurableServletWebServerFactory servletContainer() { TomcatServletWebServerFactory tomcatContainerFactory = new TomcatServletWebServerFactory(); return tomcatContainerFactory; }

Kemudian kita dapat mengonfigurasi contoh yang dikembalikan:

tomcatContainerFactory.setPort(9000); tomcatContainerFactory.setContextPath("/springboottomcatexample");

Masing-masing pengaturan khusus tersebut dapat dibuat dapat dikonfigurasi menggunakan salah satu metode yang dijelaskan sebelumnya.

Kita juga bisa langsung mengakses dan memanipulasi objek org.apache.catalina.startup.Tomcat :

Tomcat tomcat = new Tomcat(); tomcat.setPort(port); tomcat.setContextPath("/springboottomcatexample"); tomcat.start();

6. Kesimpulan

Pada artikel ini, kami telah mengulas beberapa cara untuk mendaftarkan Servlet di aplikasi Jakarta EE dan Spring Boot.

Kode sumber yang digunakan dalam tutorial ini tersedia di proyek Github.